Some comments inline On Mon, 2015-08-10 at 12:09 -0500, Matthew R. Ochs wrote: > Add superpipe supporting infrastructure to device driver for the IBM CXL > Flash adapter. This patch allows userspace applications to take advantage > of the accelerated I/O features that this adapter provides and bypass the > traditional filesystem stack. > > Signed-off-by: Matthew R. Ochs <mrochs@xxxxxxxxxxxxxxxxxx> > Signed-off-by: Manoj N. Kumar <manoj@xxxxxxxxxxxxxxxxxx> > --- > Documentation/ioctl/ioctl-number.txt | 1 + > Documentation/powerpc/cxlflash.txt | 297 +++++ > drivers/scsi/cxlflash/Makefile | 2 +- > drivers/scsi/cxlflash/common.h | 19 + > drivers/scsi/cxlflash/main.c | 21 +- > drivers/scsi/cxlflash/superpipe.c | 2206 ++++++++++++++++++++++++++++++++++ > drivers/scsi/cxlflash/superpipe.h | 127 ++ > include/uapi/scsi/Kbuild | 1 + > include/uapi/scsi/cxlflash_ioctl.h | 139 +++ > 9 files changed, 2810 insertions(+), 3 deletions(-) > create mode 100644 Documentation/powerpc/cxlflash.txt > 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/Documentation/ioctl/ioctl-number.txt b/Documentation/ioctl/ioctl-number.txt > index fdd35bf..67273e1 100644 > --- a/Documentation/ioctl/ioctl-number.txt > +++ b/Documentation/ioctl/ioctl-number.txt > @@ -315,6 +315,7 @@ Code Seq#(hex) Include File Comments > 0xC0 00-0F linux/usb/iowarrior.h > 0xC9 00-0F uapi/cxl-memcpy.h Reserved for non-upstream prototype This above doesn't exist upstream. Make sure your patch applies to a clean tree. > 0xCA 00-0F uapi/misc/cxl.h > +0xCA 80-8F uapi/scsi/cxlflash_ioctl.h > 0xCB 00-1F CBM serial IEC bus in development: > <mailto:michael.klein@xxxxxxxxxxxxxxxxxxxx> > 0xCD 01 linux/reiserfs_fs.h > diff --git a/Documentation/powerpc/cxlflash.txt b/Documentation/powerpc/cxlflash.txt > new file mode 100644 > index 0000000..4a59f1a > --- /dev/null > +++ b/Documentation/powerpc/cxlflash.txt > @@ -0,0 +1,297 @@ > +Introduction > +============ > + > + The IBM Power architecture provides support for CAPI (Coherent > + Accelerator Power Interface), which is available to certain PCIe slots > + on Power 8 systems. CAPI can be thought of as a special tunneling > + protocol through PCIe that allow PCIe adapters to look like special > + purpose co-processors which can read or write an application's > + memory and generate page faults. As a result, the host interface to > + an adapter running in CAPI mode does not require the data buffers to > + be mapped to the device's memory (IOMMU bypass) nor does it require > + memory to be pinned. > + > + On Linux, Coherent Accelerator (CXL) kernel services present CAPI > + devices as a PCI device by implementing a virtual PCI host bridge. > + This abstraction simplifies the infrastructure and programming > + model, allowing for drivers to look similar to other native PCI > + device drivers. > + > + CXL provides a mechanism by which user space applications can > + directly talk to a device (network or storage) bypassing the typical > + kernel/device driver stack. The CXL Flash Adapter Driver enables a > + user space application direct access to Flash storage. > + > + The CXL Flash Adapter Driver is a kernel module that sits in the > + SCSI stack as a low level device driver (below the SCSI disk and > + protocol drivers) for the IBM CXL Flash Adapter. This driver is > + responsible for the initialization of the adapter, setting up the > + special path for user space access, and performing error recovery. It > + communicates directly the Flash Accelerator Functional Unit (AFU) > + as described in Documentation/powerpc/cxl.txt. > + > + The cxlflash driver supports two, mutually exclusive, modes of > + operation at the device (LUN) level: > + > + - Any flash device (LUN) can be configured to be accessed as a > + regular disk device (i.e.: /dev/sdc). This is the default mode. > + > + - Any flash device (LUN) can be configured to be accessed from > + user space with a special block library. This mode further > + specifies the means of accessing the device and provides for > + either raw access to the entire LUN (referred to as direct > + or physical LUN access) or access to a kernel/AFU-mediated > + partition of the LUN (referred to as virtual LUN access). The > + segmentation of a disk device into virtual LUNs is assisted > + by special translation services provided by the Flash AFU. > + > +Overview > +======== > + > + The Coherent Accelerator Interface Architecture (CAIA) introduces a > + concept of a master context. A master typically has special privileges > + granted to it by the kernel or hypervisor allowing it to perform AFU > + wide management and control. The master may or may not be involved > + directly in each user I/O, but at the minimum is involved in the > + initial setup before the user application is allowed to send requests > + directly to the AFU. > + > + The CXL Flash Adapter Driver establishes a master context with the > + AFU. It uses memory mapped I/O (MMIO) for this control and setup. The > + Adapter Problem Space Memory Map looks like this: > + > + +-------------------------------+ > + | 512 * 64 KB User MMIO | > + | (per context) | > + | User Accessible | > + +-------------------------------+ > + | 512 * 128 B per context | > + | Provisioning and Control | > + | Trusted Process accessible | > + +-------------------------------+ > + | 64 KB Global | > + | Trusted Process accessible | > + +-------------------------------+ > + > + This driver configures itself into the SCSI software stack as an > + adapter driver. The driver is the only entity that is considered a > + Trusted Process to program the Provisioning and Control and Global > + areas in the MMIO Space shown above. The master context driver > + discovers all LUNs attached to the CXL Flash adapter and instantiates > + scsi block devices (/dev/sdb, /dev/sdc etc.) for each unique LUN > + seen from each path. > + > + Once these scsi block devices are instantiated, an application > + written to a specification provided by the block library may get > + access to the Flash from user space (without requiring a system call). > + > + This master context driver also provides a series of ioctls for this > + block library to enable this user space access. The driver supports > + two modes for accessing the block device. > + > + The first mode is called a virtual mode. In this mode a single scsi > + block device (/dev/sdb) may be carved up into any number of distinct > + virtual LUNs. The virtual LUNs may be resized as long as the sum of > + the sizes of all the virtual LUNs, along with the meta-data associated > + with it does not exceed the physical capacity. > + > + The second mode is called the physical mode. In this mode a single > + block device (/dev/sdb) may be opened directly by the block library > + and the entire space for the LUN is available to the application. > + > + Only the physical mode provides persistence of the data. i.e. The > + data written to the block device will survive application exit and > + restart and also reboot. The virtual LUNs do not persist (i.e. do > + not survive after the application terminates or the system reboots). > + > + > +Block library API > +================= > + > + Applications intending to get access to the CXL Flash from user > + space should use the block library, as it abstracts the details of > + interfacing directly with the cxlflash driver that are necessary for > + performing administrative actions (i.e.: setup, tear down, resize). > + The block library can be thought of as a 'user' of services, > + implemented as IOCTLs, that are provided by the cxlflash driver > + specifically for devices (LUNs) operating in user space access > + mode. While it is not a requirement that applications understand > + the interface between the block library and the cxlflash driver, > + a high-level overview of each supported service (IOCTL) is provided > + below. > + > + The block library can be found on GitHub: > + http://www.github.com/mikehollinger/ibmcapikv > + > + > +CXL Flash Driver IOCTLs > +======================= > + > + Users, such as the block library, that wish to interface with a flash > + device (LUN) via user space access need to use the services provided > + by the cxlflash driver. As these services are implemented as ioctls, > + a file descriptor handle must first be obtained in order to establish > + the communication channel between a user and the kernel. This file > + descriptor is obtained by opening the device special file associated > + with the scsi disk device (/dev/sdb) that was created during LUN > + discovery. As per the location of the cxlflash driver within the > + SCSI protocol stack, this open is actually not seen by the cxlflash > + driver. Upon successful open, the user receives a file descriptor > + (herein referred to as fd1) that should be used for issuing the > + subsequent ioctls listed below. > + > + The structure definitions for these IOCTLs are available in: > + uapi/scsi/cxlflash_ioctl.h > + > +DK_CXLFLASH_ATTACH > +------------------ > + > + This ioctl obtains, initializes, and starts a context using the CXL > + kernel services. These services specify a context id (u16) by which > + to uniquely identify the context and its allocated resources. The > + services additionally provide a second file descriptor (herein > + referred to as fd2) that is used by the block library to initiate > + memory mapped I/O (via mmap()) to the CXL flash device and poll for > + completion events. This file descriptor is intentionally installed by > + this driver and not the CXL kernel services to allow for intermediary > + notification and access in the event of a non-user-initiated close(), > + such as a killed process. This design point is described in further > + detail in the description for the DK_CXLFLASH_DETACH ioctl. > + > + There are a few important aspects regarding the "tokens" (context id > + and fd2) that are provided back to the user: > + > + - These tokens are only valid for the process under which they > + were created. The child of a forked process cannot continue > + to use the context id or file descriptor created by its parent > + (see DK_CXLFLASH_CLONE for further details). > + > + - These tokens are only valid for the lifetime of the context and > + the process under which they were created. Once either is > + destroyed, the tokens are to be considered stale and subsequent > + usage will result in errors. > + > + - When a context is no longer needed, the user shall detach from > + the context via the DK_CXLFLASH_DETACH ioctl. > + > + - A close on fd2 will invalidate the tokens. This operation is not > + required by the user. > + > +DK_CXLFLASH_USER_DIRECT > +----------------------- > + This ioctl is responsible for transitioning the LUN to direct > + (physical) mode access and configuring the AFU for direct access from > + user space on a per-context basis. Additionally, the block size and > + last logical block address (LBA) are returned to the user. > + > + As mentioned previously, when operating in user space access mode, > + LUNs may be accessed in whole or in part. Only one mode is allowed > + at a time and if one mode is active (outstanding references exist), > + requests to use the LUN in a different mode are denied. > + > + The AFU is configured for direct access from user space by adding an > + entry to the AFU's resource handle table. The index of the entry is > + treated as a resource handle that is returned to the user. The user > + is then able to use the handle to reference the LUN during I/O. > + > +DK_CXLFLASH_USER_VIRTUAL > +------------------------ > + This ioctl is responsible for transitioning the LUN to virtual mode > + of access and configuring the AFU for virtual access from user space > + on a per-context basis. Additionally, the block size and last logical > + block address (LBA) are returned to the user. > + > + As mentioned previously, when operating in user space access mode, > + LUNs may be accessed in whole or in part. Only one mode is allowed > + at a time and if one mode is active (outstanding references exist), > + requests to use the LUN in a different mode are denied. > + > + The AFU is configured for virtual access from user space by adding > + an entry to the AFU's resource handle table. The index of the entry > + is treated as a resource handle that is returned to the user. The > + user is then able to use the handle to reference the LUN during I/O. > + > + By default, the virtual LUN is created with a size of 0. The user > + would need to use the DK_CXLFLASH_VLUN_RESIZE ioctl to adjust the grow > + the virtual LUN to a desired size. To avoid having to perform this > + resize for the initial creation of the virtual LUN, the user has the > + option of specifying a size as part of the DK_CXLFLASH_USER_VIRTUAL > + ioctl, such that when success is returned to the user, the > + resource handle that is provided is already referencing provisioned > + storage. This is reflected by the last LBA being a non-zero value. This should be in the vlun patch. > +DK_CXLFLASH_VLUN_RESIZE > +----------------------- > + This ioctl is responsible for resizing a previously created virtual > + LUN and will fail if invoked upon a LUN that is not in virtual > + mode. Upon success, an updated last LBA is returned to the user > + indicating the new size of the virtual LUN associated with the > + resource handle. > + > + The partitioning of virtual LUNs is jointly mediated by the cxlflash > + driver and the AFU. An allocation table is kept for each LUN that is > + operating in the virtual mode and used to program a LUN translation > + table that the AFU references when provided with a resource handle. All this vlun discussion would be in the next patch not this superpipe patch. > +DK_CXLFLASH_RELEASE > +------------------- > + This ioctl is responsible for releasing a previously obtained > + reference to either a physical or virtual LUN. This can be > + thought of as the inverse of the DK_CXLFLASH_USER_DIRECT or > + DK_CXLFLASH_USER_VIRTUAL ioctls. Upon success, the resource handle > + is no longer valid and the entry in the resource handle table is > + made available to be used again. > + > + As part of the release process for virtual LUNs, the virtual LUN > + is first resized to 0 to clear out and free the translation tables > + associated with the virtual LUN reference. Looks like file_ops release calls these functions anyway. So why do we need this? > +DK_CXLFLASH_DETACH > +------------------ > + This ioctl is responsible for unregistering a context with the > + cxlflash driver and release outstanding resources that were > + not explicitly released via the DK_CXLFLASH_RELEASE ioctl. Upon > + success, all "tokens" which had been provided to the user from the > + DK_CXLFLASH_ATTACH onward are no longer valid. Why split this between detach and release? Can you reused a released context? > +DK_CXLFLASH_CLONE > +----------------- > + This ioctl is responsible for cloning a previously created > + context to a more recently created context. It exists solely to > + support maintaining user space access to storage after a process > + forks. Upon success, the child process (which invoked the ioctl) > + will have access to the same LUNs via the same resource handle(s) > + and fd2 as the parent, but under a different context. > + > + Context sharing across processes is not supported with CXL and > + therefore each fork must be met with establishing a new context > + for the child process. This ioctl simplifies the state management > + and playback required by a user in such a scenario. When a process > + forks, child process can clone the parents context by first creating > + a context (via DK_CXLFLASH_ATTACH) and then using this ioctl to > + perform the clone from the parent to the child. > + > + The clone itself is fairly simple. The resource handle and lun > + translation tables are copied from the parent context to the child's > + and then synced with the AFU. This should be in the vlun patch. Also, should be called DK_CXLFLASH_VLUN_CLONE to be consisten with VLUN_RESIZE > + > +DK_CXLFLASH_VERIFY > +------------------ > + This ioctl is used to detect various changes such as the capacity of > + the disk changing, the number of LUNs visible changing, etc. In cases > + where the changes affect the application (such as a LUN resize), the > + cxlflash driver will report the changed state to the application. > This needs a broader description. Verify exactly what? > +DK_CXLFLASH_RECOVER_AFU > +----------------------- > + This ioctl is used to drive recovery (if such an action is warranted) > + of a specified user context. Any state associated with the user context > + is re-established upon successful recovery. Why would I call this? What scenario? > + > +DK_CXLFLASH_MANAGE_LUN > +---------------------- > + This ioctl is used to switch a LUN from a mode where it is available > + for file-system access (legacy), to a mode where it is set aside for > + exclusive user space access (superpipe). In case a LUN is visible > + across multiple ports and adapters, this ioctl is used to uniquely > + identify each LUN by its World Wide Node Name (WWNN). Should this be called something specific? DK_CXLFLASH_SUPERPIPE_MODE? > diff --git a/drivers/scsi/cxlflash/Makefile b/drivers/scsi/cxlflash/Makefile > index dc95e20..3de309c 100644 > --- a/drivers/scsi/cxlflash/Makefile > +++ b/drivers/scsi/cxlflash/Makefile > @@ -1,2 +1,2 @@ > obj-$(CONFIG_CXLFLASH) += cxlflash.o > -cxlflash-y += main.o > +cxlflash-y += main.o superpipe.o > diff --git a/drivers/scsi/cxlflash/common.h b/drivers/scsi/cxlflash/common.h > index 7e663f4..a890a9a 100644 > --- a/drivers/scsi/cxlflash/common.h > +++ b/drivers/scsi/cxlflash/common.h > @@ -107,6 +107,18 @@ struct cxlflash_cfg { > struct pci_pool *cxlflash_cmd_pool; > struct pci_dev *parent_dev; > > + atomic_t recovery_threads; > + struct mutex ctx_recovery_mutex; > + struct mutex ctx_tbl_list_mutex; > + struct ctx_info *ctx_tbl[MAX_CONTEXT]; MAX_CONTEXT=512. This is pretty big! > + struct list_head ctx_err_recovery; /* contexts w/ recovery pending */ > + struct file_operations cxl_fops; > + > + atomic_t num_user_contexts; > + > + struct list_head lluns; /* list of llun_info structs */ > + spinlock_t slock; > + > wait_queue_head_t tmf_waitq; > bool tmf_active; > wait_queue_head_t limbo_waitq; > @@ -182,5 +194,12 @@ int cxlflash_afu_reset(struct cxlflash_cfg *); > struct afu_cmd *cxlflash_cmd_checkout(struct afu *); > void cxlflash_cmd_checkin(struct afu_cmd *); > int cxlflash_afu_sync(struct afu *, ctx_hndl_t, res_hndl_t, u8); > +void cxlflash_list_init(void); > +void cxlflash_list_terminate(void); > +int cxlflash_ioctl(struct scsi_device *, int, void __user *); > +void cxlflash_stop_term_user_contexts(struct cxlflash_cfg *); > +int cxlflash_mark_contexts_error(struct cxlflash_cfg *); > +void cxlflash_term_luns(struct cxlflash_cfg *); > + > #endif /* ifndef _CXLFLASH_COMMON_H */ > > diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c > index 18359d4..eb1bdd7 100644 > --- a/drivers/scsi/cxlflash/main.c > +++ b/drivers/scsi/cxlflash/main.c > @@ -519,7 +519,7 @@ static int cxlflash_eh_host_reset_handler(struct scsi_cmnd *scp) > case STATE_NORMAL: > cfg->state = STATE_LIMBO; > scsi_block_requests(cfg->host); > - > + cxlflash_mark_contexts_error(cfg); > rcr = cxlflash_afu_reset(cfg); > if (!rcr) > rc = FAILED; > @@ -723,6 +723,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, > @@ -870,9 +871,11 @@ static void cxlflash_remove(struct pci_dev *pdev) > spin_unlock_irqrestore(&cfg->tmf_waitq.lock, lock_flags); > > cfg->state = STATE_FAILTERM; > + cxlflash_stop_term_user_contexts(cfg); > > switch (cfg->init_state) { > case INIT_STATE_SCSI: > + cxlflash_term_luns(cfg); > scsi_remove_host(cfg->host); > scsi_host_put(cfg->host); > /* Fall through */ > @@ -2272,6 +2275,11 @@ static int cxlflash_probe(struct pci_dev *pdev, > INIT_WORK(&cfg->work_q, cxlflash_worker_thread); > cfg->lr_state = LINK_RESET_INVALID; > cfg->lr_port = -1; > + mutex_init(&cfg->ctx_tbl_list_mutex); > + mutex_init(&cfg->ctx_recovery_mutex); > + spin_lock_init(&cfg->slock); > + INIT_LIST_HEAD(&cfg->ctx_err_recovery); > + INIT_LIST_HEAD(&cfg->lluns); > > pci_set_drvdata(pdev, cfg); > > @@ -2333,7 +2341,9 @@ out_remove: > static pci_ers_result_t cxlflash_pci_error_detected(struct pci_dev *pdev, > pci_channel_state_t state) > { > + int rc = 0; > struct cxlflash_cfg *cfg = pci_get_drvdata(pdev); > + struct device *dev = &cfg->dev->dev; > > pr_debug("%s: pdev=%p state=%u\n", __func__, pdev, state); > > @@ -2343,7 +2353,10 @@ static pci_ers_result_t cxlflash_pci_error_detected(struct pci_dev *pdev, > > /* Turn off legacy I/O */ > scsi_block_requests(cfg->host); > - > + rc = cxlflash_mark_contexts_error(cfg); > + if (unlikely(rc)) > + dev_err(dev, "%s: Failed to mark user contexts!(%d)\n", > + __func__, rc); > term_mc(cfg, UNDO_START); > stop_afu(cfg); > > @@ -2427,6 +2440,8 @@ static int __init init_cxlflash(void) > pr_info("%s: IBM Power CXL Flash Adapter: %s\n", > __func__, CXLFLASH_DRIVER_DATE); > > + cxlflash_list_init(); > + > return pci_register_driver(&cxlflash_driver); > } > > @@ -2435,6 +2450,8 @@ static int __init init_cxlflash(void) > */ > static void __exit exit_cxlflash(void) > { > + cxlflash_list_terminate(); > + > pci_unregister_driver(&cxlflash_driver); > } > > diff --git a/drivers/scsi/cxlflash/superpipe.c b/drivers/scsi/cxlflash/superpipe.c > new file mode 100644 > index 0000000..802f1f5 > --- /dev/null > +++ b/drivers/scsi/cxlflash/superpipe.c > @@ -0,0 +1,2206 @@ > +/* > + * 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/delay.h> > +#include <linux/file.h> > +#include <linux/moduleparam.h> > +#include <linux/syscalls.h> > +#include <misc/cxl.h> > +#include <asm/unaligned.h> > + > +#include <scsi/scsi.h> > +#include <scsi/scsi_host.h> > +#include <scsi/scsi_cmnd.h> > +#include <scsi/scsi_eh.h> > +#include <uapi/scsi/cxlflash_ioctl.h> > + > +#include "sislite.h" > +#include "common.h" > +#include "superpipe.h" > + > +static struct cxlflash_global global; > + > +/** > + * marshal_det_to_rele() - translate detach to release structure > + * @detach: Destination structure for the translate/copy. > + * @rele: Source structure from which to translate/copy. > + */ > +static void marshal_det_to_rele(struct dk_cxlflash_detach *detach, > + struct dk_cxlflash_release *release) > +{ > + release->hdr = detach->hdr; > + release->context_id = detach->context_id; > +} > + > +/** > + * create_local() - allocate and initialize a local LUN information structure > + * @sdev: SCSI device associated with LUN. > + * @wwid: World Wide Node Name for LUN. > + * > + * Return: Allocated local llun_info structure on success, NULL on failure > + */ > +static struct llun_info *create_local(struct scsi_device *sdev, u8 *wwid) > +{ > + struct llun_info *lli = NULL; > + > + lli = kzalloc(sizeof(*lli), GFP_KERNEL); > + if (unlikely(!lli)) { > + pr_err("%s: could not allocate lli\n", __func__); > + goto out; > + } > + > + lli->sdev = sdev; > + lli->newly_created = true; > + lli->host_no = sdev->host->host_no; > + > + memcpy(lli->wwid, wwid, DK_CXLFLASH_MANAGE_LUN_WWID_LEN); > +out: > + return lli; > +} > + > +/** > + * create_global() - allocate and initialize a global LUN information structure > + * @sdev: SCSI device associated with LUN. > + * @wwid: World Wide Node Name for LUN. > + * > + * Return: Allocated global glun_info structure on success, NULL on failure > + */ > +static struct glun_info *create_global(struct scsi_device *sdev, u8 *wwid) > +{ > + struct glun_info *gli = NULL; > + > + gli = kzalloc(sizeof(*gli), GFP_KERNEL); > + if (unlikely(!gli)) { > + pr_err("%s: could not allocate gli\n", __func__); > + goto out; > + } > + > + memcpy(gli->wwid, wwid, DK_CXLFLASH_MANAGE_LUN_WWID_LEN); > +out: > + return gli; > +} > + > +/** > + * lookup_local() - find a local LUN information structure by WWID > + * @cfg: Internal structure associated with the host. > + * @wwid: WWID associated with LUN. > + * > + * Return: Found local lun_info structure on success, NULL on failure > + */ > +static struct llun_info *lookup_local(struct cxlflash_cfg *cfg, u8 *wwid) > +{ > + struct llun_info *lli, *temp; > + ulong lock_flags; > + > + spin_lock_irqsave(&cfg->slock, lock_flags); > + > + list_for_each_entry_safe(lli, temp, &cfg->lluns, list) > + if (!memcmp(lli->wwid, wwid, DK_CXLFLASH_MANAGE_LUN_WWID_LEN)) { > + lli->newly_created = false; > + spin_unlock_irqrestore(&cfg->slock, lock_flags); > + return lli; > + } > + > + spin_unlock_irqrestore(&cfg->slock, lock_flags); > + return NULL; > +} > + > +/** > + * lookup_global() - find a global LUN information structure by WWID > + * @wwid: WWID associated with LUN. > + * > + * Return: Found global lun_info structure on success, NULL on failure > + */ > +static struct glun_info *lookup_global(u8 *wwid) > +{ > + struct glun_info *gli, *temp; > + ulong lock_flags; > + > + spin_lock_irqsave(&global.slock, lock_flags); > + > + list_for_each_entry_safe(gli, temp, &global.gluns, list) > + if (!memcmp(gli->wwid, wwid, DK_CXLFLASH_MANAGE_LUN_WWID_LEN)) { > + spin_unlock_irqrestore(&global.slock, lock_flags); > + return gli; > + } > + > + spin_unlock_irqrestore(&global.slock, lock_flags); > + return NULL; > +} > + > +/** > + * lookup_lun() - find or create a local LUN information structure > + * @sdev: SCSI device associated with LUN. > + * @wwid: WWID associated with LUN. > + * > + * When a local LUN is not found and a global LUN is also not found, both > + * a global LUN and local LUN are created. The global LUN is added to the > + * global list and the local LUN is returned. > + * > + * Return: Found/Allocated local lun_info structure on success, NULL on failure > + */ > +static struct llun_info *lookup_lun(struct scsi_device *sdev, u8 *wwid) Should this been lookup_and_create_lun()? lookup_lun() does something quite differnt to lookup_local() despite being named simlarly. > +{ > + struct llun_info *lli = NULL; > + struct glun_info *gli = NULL; > + struct Scsi_Host *shost = sdev->host; > + struct cxlflash_cfg *cfg = shost_priv(shost); > + ulong lock_flags; > + > + if (unlikely(!wwid)) > + goto out; > + > + lli = lookup_local(cfg, wwid); > + if (lli) > + goto out; > + > + lli = create_local(sdev, wwid); > + if (unlikely(!lli)) > + goto out; > + > + gli = lookup_global(wwid); > + if (gli) { > + lli->parent = gli; > + spin_lock_irqsave(&cfg->slock, lock_flags); > + list_add(&lli->list, &cfg->lluns); > + spin_unlock_irqrestore(&cfg->slock, lock_flags); > + goto out; > + } > + > + gli = create_global(sdev, wwid); > + if (unlikely(!gli)) { > + kfree(lli); > + lli = NULL; > + goto out; > + } > + > + lli->parent = gli; > + spin_lock_irqsave(&cfg->slock, lock_flags); > + list_add(&lli->list, &cfg->lluns); > + spin_unlock_irqrestore(&cfg->slock, lock_flags); > + > + spin_lock_irqsave(&global.slock, lock_flags); > + list_add(&gli->list, &global.gluns); > + spin_unlock_irqrestore(&global.slock, lock_flags); > + > +out: > + pr_debug("%s: returning %p\n", __func__, lli); > + return lli; > +} > + > +/** > + * cxlflash_term_luns() - Delete all entries from local lun list, free. > + * @cfg: Internal structure associated with the host. > + */ > +void cxlflash_term_luns(struct cxlflash_cfg *cfg) This just does local luns? > +{ > + struct llun_info *lli, *temp; > + ulong lock_flags; > + > + spin_lock_irqsave(&cfg->slock, lock_flags); > + list_for_each_entry_safe(lli, temp, &cfg->lluns, list) { > + list_del(&lli->list); > + kfree(lli); > + } > + spin_unlock_irqrestore(&cfg->slock, lock_flags); > +} > + > +/** > + * cxlflash_list_init() - initializes the global LUN list > + */ > +void cxlflash_list_init(void) > +{ > + INIT_LIST_HEAD(&global.gluns); > + spin_lock_init(&global.slock); > + global.err_page = NULL; > +} > + > +/** > + * cxlflash_list_terminate() - frees resources associated with global LUN list > + */ > +void cxlflash_list_terminate(void) > +{ > + struct glun_info *gli, *temp; > + ulong flags = 0; > + > + spin_lock_irqsave(&global.slock, flags); > + list_for_each_entry_safe(gli, temp, &global.gluns, list) { > + list_del(&gli->list); > + kfree(gli); > + } > + > + if (global.err_page) { > + __free_page(global.err_page); > + global.err_page = NULL; > + } > + spin_unlock_irqrestore(&global.slock, flags); > +} > + > +/** > + * cxlflash_stop_term_user_contexts() - stops/terminates known user contexts > + * @cfg: Internal structure associated with the host. > + * > + * When the host needs to go down, all users must be quiesced and their > + * memory freed. This is accomplished by putting the contexts in error > + * state which will notify the user and let them 'drive' the teardown. > + * Meanwhile, this routine camps until all user contexts have been removed. > + */ > +void cxlflash_stop_term_user_contexts(struct cxlflash_cfg *cfg) > +{ > + int i, found; > + > + cxlflash_mark_contexts_error(cfg); > + > + while (true) { > + found = false; > + > + for (i = 0; i < MAX_CONTEXT; i++) > + if (cfg->ctx_tbl[i]) { > + found = true; > + break; > + } > + > + if (!found && list_empty(&cfg->ctx_err_recovery)) > + return; > + > + pr_debug("%s: Wait for user context to quiesce...\n", __func__); > + wake_up_all(&cfg->limbo_waitq); > + ssleep(1); Why 1 sec and why in a loop? Can't you poll/wait for completion somewhere? > + } > +} > + > +/** > + * find_error_context() - locates a context by cookie on the error recovery list > + * @cfg: Internal structure associated with the host. > + * @rctxid: Desired context by id. > + * @file: Desired context by file. > + * > + * Return: Found context on success, NULL on failure > + */ > +static struct ctx_info *find_error_context(struct cxlflash_cfg *cfg, u64 rctxid, > + struct file *file) > +{ > + struct ctx_info *ctxi; > + > + list_for_each_entry(ctxi, &cfg->ctx_err_recovery, list) > + if ((ctxi->ctxid == rctxid) || (ctxi->file == file)) > + return ctxi; > + > + return NULL; > +} > + > +/** > + * get_context() - obtains a validated and locked context reference > + * @cfg: Internal structure associated with the host. > + * @rctxid: Desired context (raw, undecoded format). > + * @arg: LUN information or file associated with request. > + * @ctx_ctrl: Control information to 'steer' desired lookup. > + * > + * NOTE: despite the name pid, in linux, current->pid actually refers > + * to the lightweight process id (tid) and can change if the process is > + * multi threaded. The tgid remains constant for the process and only changes > + * when the process of fork. For all intents and purposes, think of tgid > + * as a pid in the traditional sense. > + * > + * Return: Validated context on success, NULL on failure > + */ > +struct ctx_info *get_context(struct cxlflash_cfg *cfg, u64 rctxid, > + void *arg, enum ctx_ctrl ctx_ctrl) > +{ > + struct ctx_info *ctxi = NULL; > + struct lun_access *lun_access = NULL; > + struct file *file = NULL; > + struct llun_info *lli = arg; > + u64 ctxid = DECODE_CTXID(rctxid); > + int rc; > + pid_t pid = current->tgid, ctxpid = 0; > + > + if (ctx_ctrl & CTX_CTRL_FILE) { > + lli = NULL; > + file = (struct file *)arg; > + } > + > + if (ctx_ctrl & CTX_CTRL_CLONE) > + pid = current->parent->tgid; > + > + if (likely(ctxid < MAX_CONTEXT)) { > +retry: > + rc = mutex_lock_interruptible(&cfg->ctx_tbl_list_mutex); > + if (rc) > + goto out; > + > + ctxi = cfg->ctx_tbl[ctxid]; > + if (ctxi) > + if ((file && (ctxi->file != file)) || > + (!file && (ctxi->ctxid != rctxid))) > + ctxi = NULL; > + > + if ((ctx_ctrl & CTX_CTRL_ERR) || > + (!ctxi && (ctx_ctrl & CTX_CTRL_ERR_FALLBACK))) > + ctxi = find_error_context(cfg, rctxid, file); > + if (!ctxi) { > + mutex_unlock(&cfg->ctx_tbl_list_mutex); > + goto out; > + } > + > + /* > + * Need to acquire ownership of the context while still under > + * the table/list lock to serialize with a remove thread. Use > + * the 'try' to avoid stalling the table/list lock for a single > + * context. > + */ > + rc = mutex_trylock(&ctxi->mutex); > + mutex_unlock(&cfg->ctx_tbl_list_mutex); > + if (!rc) > + goto retry; Please just create a loop rather than this goto retry. > + > + if (ctxi->unavail) > + goto denied; > + > + ctxpid = ctxi->pid; > + if (likely(!(ctx_ctrl & CTX_CTRL_NOPID))) > + if (pid != ctxpid) > + goto denied; > + > + if (lli) { > + list_for_each_entry(lun_access, &ctxi->luns, list) > + if (lun_access->lli == lli) > + goto out; > + goto denied; > + } > + } > + > +out: > + pr_debug("%s: rctxid=%016llX ctxinfo=%p ctxpid=%u pid=%u ctx_ctrl=%u\n", > + __func__, rctxid, ctxi, ctxpid, pid, ctx_ctrl); > + > + return ctxi; > + > +denied: > + mutex_unlock(&ctxi->mutex); > + ctxi = NULL; > + goto out; > +} > + > +/** > + * afu_attach() - attach a context to the AFU > + * @cfg: Internal structure associated with the host. > + * @ctxi: Context to attach. > + * > + * Upon setting the context capabilities, they must be confirmed with > + * a read back operation as the context might have been closed since > + * the mailbox was unlocked. When this occurs, registration is failed. > + * > + * Return: 0 on success, -errno on failure > + */ > +static int afu_attach(struct cxlflash_cfg *cfg, struct ctx_info *ctxi) > +{ > + struct afu *afu = cfg->afu; > + struct sisl_ctrl_map *ctrl_map = ctxi->ctrl_map; > + int rc = 0; > + u64 val; > + > + /* Unlock cap and restrict user to read/write cmds in translated mode */ > + readq_be(&ctrl_map->mbox_r); > + val = (SISL_CTX_CAP_READ_CMD | SISL_CTX_CAP_WRITE_CMD); > + writeq_be(val, &ctrl_map->ctx_cap); > + val = readq_be(&ctrl_map->ctx_cap); > + if (val != (SISL_CTX_CAP_READ_CMD | SISL_CTX_CAP_WRITE_CMD)) { > + pr_err("%s: ctx may be closed val=%016llX\n", __func__, val); > + rc = -EAGAIN; > + goto out; > + } > + > + /* Set up MMIO registers pointing to the RHT */ > + writeq_be((u64)ctxi->rht_start, &ctrl_map->rht_start); > + val = SISL_RHT_CNT_ID((u64)MAX_RHT_PER_CONTEXT, (u64)(afu->ctx_hndl)); > + writeq_be(val, &ctrl_map->rht_cnt_id); > +out: > + pr_debug("%s: returning rc=%d\n", __func__, rc); > + return rc; > +} > + > +/** > + * read_cap16() - issues a SCSI READ_CAP16 command > + * @sdev: SCSI device associated with LUN. > + * @lli: LUN destined for capacity request. > + * > + * Return: 0 on success, -errno on failure > + */ > +static int read_cap16(struct scsi_device *sdev, struct llun_info *lli) > +{ > + struct glun_info *gli = lli->parent; > + u8 *buf = NULL; > + u8 *cmd_buf = NULL; > + u8 *scsi_cmd = NULL; > + u8 *sense_buf = NULL; > + int rc = 0; > + int result = 0; > + int retry_cnt = 0; > + u32 tout = (MC_DISCOVERY_TIMEOUT * HZ); > + size_t size; > + > + size = CMD_BUFSIZE + MAX_COMMAND_SIZE + SCSI_SENSE_BUFFERSIZE; > +retry: > + buf = kzalloc(size, GFP_KERNEL); > + if (unlikely(!buf)) { > + rc = -ENOMEM; > + goto out; > + } > + > + cmd_buf = buf; > + scsi_cmd = cmd_buf + CMD_BUFSIZE; > + sense_buf = scsi_cmd + MAX_COMMAND_SIZE; > + > + scsi_cmd[0] = SERVICE_ACTION_IN_16; /* read cap(16) */ > + scsi_cmd[1] = SAI_READ_CAPACITY_16; /* service action */ > + put_unaligned_be32(CMD_BUFSIZE, &scsi_cmd[10]); > + > + pr_debug("%s: %ssending cmd(0x%x)\n", __func__, retry_cnt ? "re" : "", > + scsi_cmd[0]); > + > + result = scsi_execute(sdev, scsi_cmd, DMA_FROM_DEVICE, cmd_buf, > + CMD_BUFSIZE, sense_buf, tout, 5, 0, NULL); > + > + if (driver_byte(result) == DRIVER_SENSE) { > + result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */ > + if (result & SAM_STAT_CHECK_CONDITION) { > + struct scsi_sense_hdr sshdr; > + > + scsi_normalize_sense(sense_buf, SCSI_SENSE_BUFFERSIZE, > + &sshdr); > + switch (sshdr.sense_key) { > + case NO_SENSE: > + case RECOVERED_ERROR: > + /* fall through */ > + case NOT_READY: > + result &= ~SAM_STAT_CHECK_CONDITION; > + break; > + case UNIT_ATTENTION: > + switch (sshdr.asc) { > + case 0x29: /* Power on Reset or Device Reset */ > + /* fall through */ > + case 0x2A: /* Device capacity changed */ > + case 0x3F: /* Report LUNs changed */ > + /* Retry the command once more */ > + if (retry_cnt++ < 1) { > + kfree(buf); > + goto retry; > + } > + } > + break; > + default: > + break; > + } > + } > + } > + > + if (result) { > + pr_err("%s: command failed, result=0x%x\n", __func__, result); > + rc = -EIO; > + goto out; > + } > + > + /* > + * Read cap was successful, grab values from the buffer; > + * note that we don't need to worry about unaligned access > + * as the buffer is allocated on an aligned boundary. > + */ > + spin_lock(&gli->slock); > + gli->max_lba = be64_to_cpu(*((u64 *)&cmd_buf[0])); > + gli->blk_len = be32_to_cpu(*((u32 *)&cmd_buf[8])); > + spin_unlock(&gli->slock); > + > +out: > + kfree(buf); > + pr_debug("%s: maxlba=%lld blklen=%d rc=%d\n", __func__, > + gli->max_lba, gli->blk_len, rc); > + return rc; > +} > + > +/** > + * get_rhte() - obtains validated resource handle table entry reference > + * @ctxi: Context owning the resource handle. > + * @rhndl: Resource handle associated with entry. > + * @lli: LUN associated with request. > + * > + * Return: Validated RHTE on success, NULL on failure > + */ > +struct sisl_rht_entry *get_rhte(struct ctx_info *ctxi, res_hndl_t rhndl, > + struct llun_info *lli) > +{ > + struct sisl_rht_entry *rhte = NULL; > + > + if (unlikely(!ctxi->rht_start)) { > + pr_err("%s: Context does not have allocated RHT!\n", __func__); > + goto out; > + } > + > + if (unlikely(rhndl >= MAX_RHT_PER_CONTEXT)) { > + pr_err("%s: Bad resource handle! (%d)\n", __func__, rhndl); > + goto out; > + } > + > + if (unlikely(ctxi->rht_lun[rhndl] != lli)) { > + pr_err("%s: Bad resource handle LUN! (%d)\n", __func__, rhndl); > + goto out; > + } > + > + rhte = &ctxi->rht_start[rhndl]; > + if (unlikely(rhte->nmask == 0)) { > + pr_err("%s: Unopened resource handle! (%d)\n", __func__, rhndl); > + rhte = NULL; > + goto out; > + } > + > +out: > + return rhte; > +} > + > +/** > + * rhte_checkout() - obtains free/empty resource handle table entry > + * @ctxi: Context owning the resource handle. > + * @lli: LUN associated with request. > + * > + * Return: Free RHTE on success, NULL on failure > + */ > +struct sisl_rht_entry *rhte_checkout(struct ctx_info *ctxi, > + struct llun_info *lli) > +{ > + struct sisl_rht_entry *rhte = NULL; > + int i; > + > + /* Find a free RHT entry */ > + for (i = 0; i < MAX_RHT_PER_CONTEXT; i++) > + if (ctxi->rht_start[i].nmask == 0) { > + rhte = &ctxi->rht_start[i]; > + ctxi->rht_out++; > + break; > + } > + > + if (likely(rhte)) > + ctxi->rht_lun[i] = lli; > + > + pr_debug("%s: returning rhte=%p (%d)\n", __func__, rhte, i); > + return rhte; > +} > + > +/** > + * rhte_checkin() - releases a resource handle table entry > + * @ctxi: Context owning the resource handle. > + * @rhte: RHTE to release. > + */ > +void rhte_checkin(struct ctx_info *ctxi, > + struct sisl_rht_entry *rhte) > +{ > + u32 rsrc_handle = rhte - ctxi->rht_start; > + > + rhte->nmask = 0; > + rhte->fp = 0; > + ctxi->rht_out--; > + ctxi->rht_lun[rsrc_handle] = NULL; > +} > + > +/** > + * rhte_format1() - populates a RHTE for format 1 > + * @rhte: RHTE to populate. > + * @lun_id: LUN ID of LUN associated with RHTE. > + * @perm: Desired permissions for RHTE. > + * @port_sel: Port selection mask > + */ > +static void rht_format1(struct sisl_rht_entry *rhte, u64 lun_id, u32 perm, > + u32 port_sel) > +{ > + /* > + * Populate the Format 1 RHT entry for direct access (physical > + * LUN) using the synchronization sequence defined in the > + * SISLite specification. > + */ > + struct sisl_rht_entry_f1 dummy = { 0 }; > + struct sisl_rht_entry_f1 *rhte_f1 = (struct sisl_rht_entry_f1 *)rhte; > + > + memset(rhte_f1, 0, sizeof(*rhte_f1)); > + rhte_f1->fp = SISL_RHT_FP(1U, 0); > + dma_wmb(); /* Make setting of format bit visible */ > + > + rhte_f1->lun_id = lun_id; > + dma_wmb(); /* Make setting of LUN id visible */ > + > + /* > + * Use a dummy RHT Format 1 entry to build the second dword > + * of the entry that must be populated in a single write when > + * enabled (valid bit set to TRUE). > + */ > + dummy.valid = 0x80; > + dummy.fp = SISL_RHT_FP(1U, perm); > + dummy.port_sel = port_sel; > + rhte_f1->dw = dummy.dw; > + > + dma_wmb(); /* Make remaining RHT entry fields visible */ > +} > + > +/** > + * cxlflash_lun_attach() - attaches a user to a LUN and manages the LUN's mode > + * @gli: LUN to attach. > + * @mode: Desired mode of the LUN. > + * > + * Return: 0 on success, -errno on failure > + */ > +int cxlflash_lun_attach(struct glun_info *gli, enum lun_mode mode) > +{ > + int rc = 0; > + > + spin_lock(&gli->slock); > + if (gli->mode == MODE_NONE) > + gli->mode = mode; > + else if (gli->mode != mode) { > + pr_err("%s: LUN operating in mode %d, requested mode %d\n", > + __func__, gli->mode, mode); > + rc = -EINVAL; > + goto out; > + } > + > + gli->users++; > + WARN_ON(gli->users <= 0); > +out: > + pr_debug("%s: Returning rc=%d gli->mode=%u gli->users=%u\n", > + __func__, rc, gli->mode, gli->users); > + spin_unlock(&gli->slock); > + return rc; > +} > + > +/** > + * cxlflash_lun_detach() - detaches a user from a LUN and resets the LUN's mode > + * @gli: LUN to detach. > + * > + * When resetting the mode, terminate block allocation resources as they > + * are no longer required (service is safe to call even when block allocation > + * resources were not present - such as when transitioning from physical mode). > + * These resources will be reallocated when needed (subsequent transition to > + * virtual mode). > + */ > +void cxlflash_lun_detach(struct glun_info *gli) > +{ > + spin_lock(&gli->slock); > + WARN_ON(gli->mode == MODE_NONE); > + if (--gli->users == 0) > + gli->mode = MODE_NONE; > + pr_debug("%s: gli->users=%u\n", __func__, gli->users); > + WARN_ON(gli->users < 0); > + spin_unlock(&gli->slock); > +} > + > +/** > + * _cxlflash_disk_release() - releases the specified resource entry > + * @sdev: SCSI device associated with LUN. > + * @ctxi: Context owning resources. > + * @release: Release ioctl data structure. > + * > + * For LUN's in virtual mode, the virtual lun associated with the specified > + * resource handle is resized to 0 prior to releasing the RHTE. Note that the > + * AFU sync should _not_ be performed when the context is sitting on the error > + * recovery list. A context on the error recovery list is not known to the AFU > + * due to reset. When the context is recovered, it will be reattached and made > + * known again to the AFU. > + * > + * Return: 0 on success, -errno on failure > + */ > +int _cxlflash_disk_release(struct scsi_device *sdev, > + struct ctx_info *ctxi, > + struct dk_cxlflash_release *release) > +{ > + struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata; > + struct llun_info *lli = sdev->hostdata; > + struct glun_info *gli = lli->parent; > + struct afu *afu = cfg->afu; > + bool unlock_ctx = false; > + > + res_hndl_t rhndl = release->rsrc_handle; > + > + int rc = 0; > + u64 ctxid = DECODE_CTXID(release->context_id), > + rctxid = release->context_id; > + > + struct sisl_rht_entry *rhte; > + struct sisl_rht_entry_f1 *rhte_f1; > + > + pr_debug("%s: ctxid=%llu rhndl=0x%llx gli->mode=%u gli->users=%u\n", > + __func__, ctxid, release->rsrc_handle, gli->mode, gli->users); > + > + if (!ctxi) { > + ctxi = get_context(cfg, rctxid, lli, CTX_CTRL_ERR_FALLBACK); > + if (unlikely(!ctxi)) { > + pr_err("%s: Bad context! (%llu)\n", __func__, ctxid); > + rc = -EINVAL; > + goto out; > + } > + > + unlock_ctx = true; > + } > + > + rhte = get_rhte(ctxi, rhndl, lli); > + if (unlikely(!rhte)) { > + pr_err("%s: Bad resource handle! (%d)\n", __func__, rhndl); > + rc = -EINVAL; > + goto out; > + } > + > + /* > + * Resize to 0 for virtual LUNS by setting the size > + * to 0. This will clear LXT_START and LXT_CNT fields > + * in the RHT entry and properly sync with the AFU. > + * > + * Afterwards we clear the remaining fields. > + */ > + switch (gli->mode) { > + case MODE_PHYSICAL: > + /* > + * Clear the Format 1 RHT entry for direct access > + * (physical LUN) using the synchronization sequence > + * defined in the SISLite specification. > + */ > + rhte_f1 = (struct sisl_rht_entry_f1 *)rhte; > + > + rhte_f1->valid = 0; > + dma_wmb(); /* Make revocation of RHT entry visible */ > + > + rhte_f1->lun_id = 0; > + dma_wmb(); /* Make clearing of LUN id visible */ > + > + rhte_f1->dw = 0; > + dma_wmb(); /* Make RHT entry bottom-half clearing visible */ > + > + if (!ctxi->err_recovery_active) > + cxlflash_afu_sync(afu, ctxid, rhndl, AFU_HW_SYNC); > + break; > + default: > + WARN(1, "Unsupported LUN mode!"); > + goto out; > + } > + > + rhte_checkin(ctxi, rhte); > + cxlflash_lun_detach(gli); > + > +out: > + if (unlock_ctx) > + mutex_unlock(&ctxi->mutex); Where is the matching lock for this? > + pr_debug("%s: returning rc=%d\n", __func__, rc); > + return rc; > +} > + > +int cxlflash_disk_release(struct scsi_device *sdev, > + struct dk_cxlflash_release *release) > +{ > + return _cxlflash_disk_release(sdev, NULL, release); > +} > + > +/** > + * destroy_context() - releases a context > + * @cfg: Internal structure associated with the host. > + * @ctxi: Context to release. > + * > + * Note that the rht_lun member of the context was cut from a single > + * allocation when the context was created and therefore does not need > + * to be explicitly freed. Also note that we conditionally check for the > + * existence of the context control map before clearing the RHT registers > + * and context capbilities because it is possible to destroy a context > + * while the context is in the error state (previous mapping was removed > + * [so we don't have to worry about clearing] and context is waiting for > + * a new mapping). > + */ > +static void destroy_context(struct cxlflash_cfg *cfg, > + struct ctx_info *ctxi) > +{ > + struct afu *afu = cfg->afu; > + > + WARN_ON(!list_empty(&ctxi->luns)); > + > + /* Clear RHT registers and drop all capabilities for this context */ > + if (afu->afu_map && ctxi->ctrl_map) { > + writeq_be(0, &ctxi->ctrl_map->rht_start); > + writeq_be(0, &ctxi->ctrl_map->rht_cnt_id); > + writeq_be(0, &ctxi->ctrl_map->ctx_cap); > + } > + > + /* > + * Free the RHT memory and context; note that rht_lun > + * was carved from the same memory as the context. > + */ > + free_page((ulong)ctxi->rht_start); > + kfree(ctxi); > + atomic_dec_if_positive(&cfg->num_user_contexts); > +} > + > +/** > + * create_context() - allocates and initializes a context > + * @cfg: Internal structure associated with the host. > + * @ctx: Previously obtained CXL context reference. > + * @ctxid: Previously obtained process element associated with CXL context. > + * @adap_fd: Previously obtained adapter fd associated with CXL context. > + * @file: Previously obtained file associated with CXL context. > + * @perms: User-specified permissions. > + * > + * The context's mutex is locked when an allocated context is returned. > + * > + * Return: Allocated context on success, NULL on failure > + */ > +static struct ctx_info *create_context(struct cxlflash_cfg *cfg, > + struct cxl_context *ctx, int ctxid, > + int adap_fd, struct file *file, > + u32 perms) > +{ > + char *tmp = NULL; > + size_t size; > + struct afu *afu = cfg->afu; > + struct ctx_info *ctxi = NULL; > + struct sisl_rht_entry *rhte; > + > + size = (MAX_RHT_PER_CONTEXT * sizeof(*ctxi->rht_lun)); > + size += sizeof(*ctxi); > + > + tmp = kzalloc(size, GFP_KERNEL); Just do two allocs. One for ctxi and one for rht_lun. This is overly complicated. > + if (unlikely(!tmp)) { > + pr_err("%s: Unable to allocate context! (%ld)\n", > + __func__, size); > + goto out; > + } > + > + rhte = (struct sisl_rht_entry *)get_zeroed_page(GFP_KERNEL); > + if (unlikely(!rhte)) { > + pr_err("%s: Unable to allocate RHT!\n", __func__); > + goto err; > + } > + > + ctxi = (struct ctx_info *)tmp; > + tmp += sizeof(*ctxi); > + ctxi->rht_lun = (struct llun_info **)tmp; Yuck... just do two allocs rather than this throbbing. > + ctxi->rht_start = rhte; > + ctxi->rht_perms = perms; > + > + ctxi->ctrl_map = &afu->afu_map->ctrls[ctxid].ctrl; > + ctxi->ctxid = ENCODE_CTXID(ctxi, ctxid); > + ctxi->lfd = adap_fd; > + ctxi->pid = current->tgid; /* tgid = pid */ > + ctxi->ctx = ctx; > + ctxi->file = file; > + mutex_init(&ctxi->mutex); > + INIT_LIST_HEAD(&ctxi->luns); > + INIT_LIST_HEAD(&ctxi->list); /* initialize for list_empty() */ > + > + atomic_inc(&cfg->num_user_contexts); > + mutex_lock(&ctxi->mutex); > +out: > + return ctxi; > + > +err: > + kfree(tmp); > + goto out; > +} > + > +/** > + * _cxlflash_disk_detach() - detaches a LUN from a context > + * @sdev: SCSI device associated with LUN. > + * @ctxi: Context owning resources. > + * @detach: Detach ioctl data structure. > + * > + * As part of the detach, all per-context resources associated with the LUN > + * are cleaned up. When detaching the last LUN for a context, the context > + * itself is cleaned up and released. > + * > + * Return: 0 on success, -errno on failure > + */ > +static int _cxlflash_disk_detach(struct scsi_device *sdev, > + struct ctx_info *ctxi, > + struct dk_cxlflash_detach *detach) > +{ > + struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata; > + struct llun_info *lli = sdev->hostdata; > + struct lun_access *lun_access, *t; > + struct dk_cxlflash_release rel; > + bool unlock_ctx = false; > + > + int i; > + int rc = 0; > + int lfd; > + u64 ctxid = DECODE_CTXID(detach->context_id), > + rctxid = detach->context_id; > + > + pr_debug("%s: ctxid=%llu\n", __func__, ctxid); > + > + if (!ctxi) { > + ctxi = get_context(cfg, rctxid, lli, CTX_CTRL_ERR_FALLBACK); > + if (unlikely(!ctxi)) { > + pr_err("%s: Bad context! (%llu)\n", __func__, ctxid); > + rc = -EINVAL; > + goto out; > + } > + > + unlock_ctx = true; > + } > + > + /* Cleanup outstanding resources tied to this LUN */ > + if (ctxi->rht_out) { > + marshal_det_to_rele(detach, &rel); > + for (i = 0; i < MAX_RHT_PER_CONTEXT; i++) { > + if (ctxi->rht_lun[i] == lli) { > + rel.rsrc_handle = i; > + _cxlflash_disk_release(sdev, ctxi, &rel); > + } > + > + /* No need to loop further if we're done */ > + if (ctxi->rht_out == 0) > + break; > + } > + } > + > + /* Take our LUN out of context, free the node */ > + list_for_each_entry_safe(lun_access, t, &ctxi->luns, list) > + if (lun_access->lli == lli) { > + list_del(&lun_access->list); > + kfree(lun_access); > + lun_access = NULL; > + break; > + } > + > + /* Tear down context following last LUN cleanup */ > + if (list_empty(&ctxi->luns)) { > + ctxi->unavail = true; > + mutex_unlock(&ctxi->mutex); > + mutex_lock(&cfg->ctx_tbl_list_mutex); > + mutex_lock(&ctxi->mutex); > + > + /* Might not have been in error list so conditionally remove */ > + if (!list_empty(&ctxi->list)) > + list_del(&ctxi->list); > + cfg->ctx_tbl[ctxid] = NULL; > + mutex_unlock(&cfg->ctx_tbl_list_mutex); > + mutex_unlock(&ctxi->mutex); > + > + lfd = ctxi->lfd; > + destroy_context(cfg, ctxi); > + ctxi = NULL; > + unlock_ctx = false; > + > + /* > + * As a last step, clean up external resources when not > + * already on an external cleanup thread, ie: close(adap_fd). > + * > + * NOTE: this will free up the context from the CXL services, > + * allowing it to dole out the same context_id on a future > + * (or even currently in-flight) disk_attach operation. > + */ > + if (lfd != -1) > + sys_close(lfd); > + } > + > +out: > + if (unlock_ctx) > + mutex_unlock(&ctxi->mutex); Where is the matching lock for this? > + pr_debug("%s: returning rc=%d\n", __func__, rc); > + return rc; > +} > + > +static int cxlflash_disk_detach(struct scsi_device *sdev, > + struct dk_cxlflash_detach *detach) > +{ > + return _cxlflash_disk_detach(sdev, NULL, detach); > +} > + > +/** > + * cxlflash_cxl_release() - release handler for adapter file descriptor > + * @inode: Filesystem inode associated with fd. > + * @file: File installed with adapter file descriptor. > + * > + * This routine is the release handler for the fops registered with > + * the CXL services on an initial attach for a context. It is called > + * when a close is performed on the adapter file descriptor returned > + * to the user. Programmatically, the user is not required to perform > + * the close, as it is handled internally via the detach ioctl when > + * a context is being removed. Note that nothing prevents the user > + * from performing a close, but the user should be aware that doing > + * so is considered catastrophic and subsequent usage of the superpipe > + * API with previously saved off tokens will fail. > + * > + * When initiated from an external close (either by the user or via > + * a process tear down), the routine derives the context reference > + * and calls detach for each LUN associated with the context. The > + * final detach operation will cause the context itself to be freed. > + * Note that the saved off lfd is reset prior to calling detach to > + * signify that the final detach should not perform a close. > + * > + * When initiated from a detach operation as part of the tear down > + * of a context, the context is first completely freed and then the > + * close is performed. This routine will fail to derive the context > + * reference (due to the context having already been freed) and then > + * call into the CXL release entry point. > + * > + * Thus, with exception to when the CXL process element (context id) > + * lookup fails (a case that should theoretically never occur), every > + * call into this routine results in a complete freeing of a context. > + * > + * As part of the detach, all per-context resources associated with the LUN > + * are cleaned up. When detaching the last LUN for a context, the context > + * itself is cleaned up and released. > + * > + * Return: 0 on success > + */ > +static int cxlflash_cxl_release(struct inode *inode, struct file *file) > +{ > + struct cxl_context *ctx = cxl_fops_get_context(file); > + struct cxlflash_cfg *cfg = container_of(file->f_op, struct cxlflash_cfg, > + cxl_fops); > + struct ctx_info *ctxi = NULL; > + struct dk_cxlflash_detach detach = { { 0 }, 0 }; > + struct lun_access *lun_access, *t; > + enum ctx_ctrl ctrl = CTX_CTRL_ERR_FALLBACK | CTX_CTRL_FILE; > + int ctxid; > + > + ctxid = cxl_process_element(ctx); > + if (unlikely(ctxid < 0)) { > + pr_err("%s: Context %p was closed! (%d)\n", > + __func__, ctx, ctxid); > + goto out; > + } > + > + ctxi = get_context(cfg, ctxid, file, ctrl); > + if (unlikely(!ctxi)) { > + ctxi = get_context(cfg, ctxid, file, ctrl | CTX_CTRL_CLONE); > + if (!ctxi) { > + pr_debug("%s: Context %d already free!\n", > + __func__, ctxid); > + goto out_release; > + } > + > + pr_debug("%s: Another process owns context %d!\n", > + __func__, ctxid); > + mutex_unlock(&ctxi->mutex); > + goto out; > + } > + > + pr_debug("%s: close(%d) for context %d\n", > + __func__, ctxi->lfd, ctxid); > + > + /* Reset the file descriptor to indicate we're on a close() thread */ > + ctxi->lfd = -1; > + detach.context_id = ctxi->ctxid; > + list_for_each_entry_safe(lun_access, t, &ctxi->luns, list) > + _cxlflash_disk_detach(lun_access->sdev, ctxi, &detach); > +out_release: > + cxl_fd_release(inode, file); > +out: > + pr_debug("%s: returning\n", __func__); > + return 0; > +} > + > +/** > + * unmap_context() - clears a previously established mapping > + * @ctxi: Context owning the mapping. > + * > + * This routine is used to switch between the error notification page > + * (dummy page of all 1's) and the real mapping (established by the CXL > + * fault handler). > + */ > +static void unmap_context(struct ctx_info *ctxi) > +{ > + unmap_mapping_range(ctxi->file->f_mapping, 0, 0, 1); > +} > + > +/** > + * get_err_page() - obtains and allocates the error notification page > + * > + * Return: error notification page on success, NULL on failure > + */ > +static struct page *get_err_page(void) > +{ > + struct page *err_page = global.err_page; > + ulong flags = 0; > + > + if (unlikely(!err_page)) { > + err_page = alloc_page(GFP_KERNEL); > + if (unlikely(!err_page)) { > + pr_err("%s: Unable to allocate err_page!\n", __func__); > + goto out; > + } > + > + memset(page_address(err_page), -1, PAGE_SIZE); > + > + /* Serialize update w/ other threads to avoid a leak */ > + spin_lock_irqsave(&global.slock, flags); > + if (likely(!global.err_page)) > + global.err_page = err_page; > + else { > + __free_page(err_page); > + err_page = global.err_page; > + } > + spin_unlock_irqrestore(&global.slock, flags); > + } > + > +out: > + pr_debug("%s: returning err_page=%p\n", __func__, err_page); > + return err_page; > +} > + > +/** > + * cxlflash_mmap_fault() - mmap fault handler for adapter file descriptor > + * @vma: VM area associated with mapping. > + * @vmf: VM fault associated with current fault. > + * > + * To support error notification via MMIO, faults are 'caught' by this routine > + * that was inserted before passing back the adapter file descriptor on attach. > + * When a fault occurs, this routine evaluates if error recovery is active and > + * if so, installs the error page to 'notify' the user about the error state. > + * During normal operation, the fault is simply handled by the original fault > + * handler that was installed by CXL services as part of initializing the > + * adapter file descriptor. The VMA's page protection bits are toggled to > + * indicate cached/not-cached depending on the memory backing the fault. > + * > + * Return: 0 on success, VM_FAULT_SIGBUS on failure > + */ > +static int cxlflash_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf) > +{ > + struct file *file = vma->vm_file; > + struct cxl_context *ctx = cxl_fops_get_context(file); > + struct cxlflash_cfg *cfg = container_of(file->f_op, struct cxlflash_cfg, > + cxl_fops); > + struct ctx_info *ctxi = NULL; > + struct page *err_page = NULL; > + enum ctx_ctrl ctrl = CTX_CTRL_ERR_FALLBACK | CTX_CTRL_FILE; > + int rc = 0; > + int ctxid; > + > + ctxid = cxl_process_element(ctx); > + if (unlikely(ctxid < 0)) { > + pr_err("%s: Context %p was closed! (%d)\n", > + __func__, ctx, ctxid); > + goto err; > + } > + > + ctxi = get_context(cfg, ctxid, file, ctrl); > + if (unlikely(!ctxi)) { > + pr_err("%s: Bad context! (%d)\n", __func__, ctxid); > + goto err; > + } > + > + pr_debug("%s: fault(%d) for context %d\n", > + __func__, ctxi->lfd, ctxid); > + > + if (likely(!ctxi->err_recovery_active)) { > + vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); > + rc = ctxi->cxl_mmap_vmops->fault(vma, vmf); > + } else { > + pr_debug("%s: err recovery active, use err_page!\n", __func__); > + > + err_page = get_err_page(); > + if (unlikely(!err_page)) { > + pr_err("%s: Could not obtain error page!\n", __func__); > + rc = VM_FAULT_RETRY; > + goto out; > + } > + > + get_page(err_page); > + vmf->page = err_page; > + vma->vm_page_prot = pgprot_cached(vma->vm_page_prot); > + } > + > +out: > + if (likely(ctxi)) > + mutex_unlock(&ctxi->mutex); > + pr_debug("%s: returning rc=%d\n", __func__, rc); > + return rc; > + > +err: > + rc = VM_FAULT_SIGBUS; > + goto out; > +} > + > +/* > + * Local MMAP vmops to 'catch' faults > + */ > +static const struct vm_operations_struct cxlflash_mmap_vmops = { > + .fault = cxlflash_mmap_fault, > +}; > + > +/** > + * cxlflash_cxl_mmap() - mmap handler for adapter file descriptor > + * @file: File installed with adapter file descriptor. > + * @vma: VM area associated with mapping. > + * > + * Installs local mmap vmops to 'catch' faults for error notification support. > + * > + * Return: 0 on success, -errno on failure > + */ > +static int cxlflash_cxl_mmap(struct file *file, struct vm_area_struct *vma) > +{ > + struct cxl_context *ctx = cxl_fops_get_context(file); > + struct cxlflash_cfg *cfg = container_of(file->f_op, struct cxlflash_cfg, > + cxl_fops); > + struct ctx_info *ctxi = NULL; > + enum ctx_ctrl ctrl = CTX_CTRL_ERR_FALLBACK | CTX_CTRL_FILE; > + int ctxid; > + int rc = 0; > + > + ctxid = cxl_process_element(ctx); > + if (unlikely(ctxid < 0)) { > + pr_err("%s: Context %p was closed! (%d)\n", > + __func__, ctx, ctxid); > + rc = -EIO; > + goto out; > + } > + > + ctxi = get_context(cfg, ctxid, file, ctrl); > + if (unlikely(!ctxi)) { > + pr_err("%s: Bad context! (%d)\n", __func__, ctxid); > + rc = -EIO; > + goto out; > + } > + > + pr_debug("%s: mmap(%d) for context %d\n", __func__, ctxi->lfd, ctxid); > + > + rc = cxl_fd_mmap(file, vma); > + if (likely(!rc)) { > + /* Insert ourself in the mmap fault handler path */ > + ctxi->cxl_mmap_vmops = vma->vm_ops; > + vma->vm_ops = &cxlflash_mmap_vmops; > + } > + > +out: > + if (likely(ctxi)) > + mutex_unlock(&ctxi->mutex); Where is the matching lock for this? > + return rc; > +} > + > +/* > + * Local fops for adapter file descriptor > + */ > +static const struct file_operations cxlflash_cxl_fops = { > + .owner = THIS_MODULE, > + .mmap = cxlflash_cxl_mmap, > + .release = cxlflash_cxl_release, > +}; > + > +/** > + * cxlflash_mark_contexts_error() - move contexts to error state and list > + * @cfg: Internal structure associated with the host. > + * > + * A context is only moved over to the error list when there are no outstanding > + * references to it. This ensures that a running operation has completed. > + * > + * Return: 0 on success, -errno on failure > + */ > +int cxlflash_mark_contexts_error(struct cxlflash_cfg *cfg) > +{ > + int i, rc = 0; > + struct ctx_info *ctxi = NULL; > + > + mutex_lock(&cfg->ctx_tbl_list_mutex); > + > + for (i = 0; i < MAX_CONTEXT; i++) { > + ctxi = cfg->ctx_tbl[i]; > + if (ctxi) { > + mutex_lock(&ctxi->mutex); > + cfg->ctx_tbl[i] = NULL; > + list_add(&ctxi->list, &cfg->ctx_err_recovery); > + ctxi->err_recovery_active = true; > + ctxi->ctrl_map = NULL; > + unmap_context(ctxi); > + mutex_unlock(&ctxi->mutex); > + } > + } > + > + mutex_unlock(&cfg->ctx_tbl_list_mutex); > + return rc; > +} > + > +/* > + * Dummy NULL fops > + */ > +static const struct file_operations null_fops = { > + .owner = THIS_MODULE, > +}; > + > +/** > + * cxlflash_disk_attach() - attach a LUN to a context > + * @sdev: SCSI device associated with LUN. > + * @attach: Attach ioctl data structure. > + * > + * Creates a context and attaches LUN to it. A LUN can only be attached > + * one time to a context (subsequent attaches for the same context/LUN pair > + * are not supported). Additional LUNs can be attached to a context by > + * specifying the 'reuse' flag defined in the cxlflash_ioctl.h header. > + * > + * Return: 0 on success, -errno on failure > + */ > +static int cxlflash_disk_attach(struct scsi_device *sdev, > + struct dk_cxlflash_attach *attach) > +{ > + struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata; > + struct afu *afu = cfg->afu; > + struct llun_info *lli = sdev->hostdata; > + struct glun_info *gli = lli->parent; > + struct cxl_ioctl_start_work *work; > + struct ctx_info *ctxi = NULL; > + struct lun_access *lun_access = NULL; > + int rc = 0; > + u32 perms; > + int ctxid = -1; > + u64 rctxid = 0UL; > + struct file *file; > + > + struct cxl_context *ctx; > + > + int fd = -1; > + > + /* On first attach set fileops */ > + if (atomic_read(&cfg->num_user_contexts) == 0) > + cfg->cxl_fops = cxlflash_cxl_fops; > + > + if (attach->num_interrupts > 4) { > + pr_err("%s: Cannot support this many interrupts %llu\n", > + __func__, attach->num_interrupts); > + rc = -EINVAL; > + goto out; > + } > + > + if (gli->max_lba == 0) { > + pr_debug("%s: No capacity info yet for this LUN (%016llX)\n", > + __func__, lli->lun_id[sdev->channel]); > + rc = read_cap16(sdev, lli); > + if (rc) { > + pr_err("%s: Invalid device! (%d)\n", __func__, rc); > + rc = -ENODEV; > + goto out; > + } > + pr_debug("%s: LBA = %016llX\n", __func__, gli->max_lba); > + pr_debug("%s: BLK_LEN = %08X\n", __func__, gli->blk_len); > + } > + > + if (attach->hdr.flags & DK_CXLFLASH_ATTACH_REUSE_CONTEXT) { > + rctxid = attach->context_id; > + ctxi = get_context(cfg, rctxid, NULL, 0); > + if (!ctxi) { > + pr_err("%s: Bad context! (%016llX)\n", > + __func__, rctxid); > + rc = -EINVAL; > + goto out; > + } > + > + list_for_each_entry(lun_access, &ctxi->luns, list) > + if (lun_access->lli == lli) { > + pr_err("%s: Already attached!\n", __func__); > + rc = -EINVAL; > + goto out; > + } > + } > + > + lun_access = kzalloc(sizeof(*lun_access), GFP_KERNEL); > + if (unlikely(!lun_access)) { > + pr_err("%s: Unable to allocate lun_access!\n", __func__); > + rc = -ENOMEM; > + goto out; > + } > + > + lun_access->lli = lli; > + lun_access->sdev = sdev; > + > + /* Non-NULL context indicates reuse */ > + if (ctxi) { > + pr_debug("%s: Reusing context for LUN! (%016llX)\n", > + __func__, rctxid); > + list_add(&lun_access->list, &ctxi->luns); > + fd = ctxi->lfd; > + goto out_attach; > + } > + > + ctx = cxl_dev_context_init(cfg->dev); > + if (unlikely(IS_ERR_OR_NULL(ctx))) { > + pr_err("%s: Could not initialize context %p\n", __func__, ctx); > + rc = -ENODEV; > + goto err0; > + } > + > + ctxid = cxl_process_element(ctx); > + if (unlikely((ctxid > MAX_CONTEXT) || (ctxid < 0))) { > + pr_err("%s: ctxid (%d) invalid!\n", __func__, ctxid); > + rc = -EPERM; > + goto err1; > + } > + > + file = cxl_get_fd(ctx, &cfg->cxl_fops, &fd); You should create a new fops for each call here. We write the fops to fill it out. I think it'll work as you have now but it's a bit dodgy. > + if (unlikely(fd < 0)) { > + rc = -ENODEV; > + pr_err("%s: Could not get file descriptor\n", __func__); > + goto err1; > + } > + > + /* Translate read/write O_* flags from fcntl.h to AFU permission bits */ > + perms = SISL_RHT_PERM(attach->hdr.flags + 1); > + > + ctxi = create_context(cfg, ctx, ctxid, fd, file, perms); > + if (unlikely(!ctxi)) { > + pr_err("%s: Failed to create context! (%d)\n", __func__, ctxid); > + goto err2; > + } > + > + work = &ctxi->work; > + work->num_interrupts = attach->num_interrupts; > + work->flags = CXL_START_WORK_NUM_IRQS; > + > + rc = cxl_start_work(ctx, work); > + if (unlikely(rc)) { > + pr_debug("%s: Could not start context rc=%d\n", __func__, rc); > + goto err3; > + } > + > + rc = afu_attach(cfg, ctxi); > + if (unlikely(rc)) { > + pr_err("%s: Could not attach AFU rc %d\n", __func__, rc); > + goto err4; > + } > + > + /* > + * No error paths after this point. Once the fd is installed it's > + * visible to user space and can't be undone safely on this thread. > + * There is no need to worry about a deadlock here because no one > + * knows about us yet; we can be the only one holding our mutex. > + */ > + list_add(&lun_access->list, &ctxi->luns); > + mutex_unlock(&ctxi->mutex); Where is the matching lock for this? > + mutex_lock(&cfg->ctx_tbl_list_mutex); > + mutex_lock(&ctxi->mutex); > + cfg->ctx_tbl[ctxid] = ctxi; > + mutex_unlock(&cfg->ctx_tbl_list_mutex); > + fd_install(fd, file); > + > +out_attach: > + attach->hdr.return_flags = 0; > + attach->context_id = ctxi->ctxid; > + attach->block_size = gli->blk_len; > + attach->mmio_size = sizeof(afu->afu_map->hosts[0].harea); > + attach->last_lba = gli->max_lba; > + attach->max_xfer = (sdev->host->max_sectors * 512) / gli->blk_len; > + > +out: > + attach->adap_fd = fd; > + > + if (ctxi) > + mutex_unlock(&ctxi->mutex); > + > + pr_debug("%s: returning ctxid=%d fd=%d bs=%lld rc=%d llba=%lld\n", > + __func__, ctxid, fd, attach->block_size, rc, attach->last_lba); > + return rc; > + > +err4: > + cxl_stop_context(ctx); > +err3: > + mutex_unlock(&ctxi->mutex); > + destroy_context(cfg, ctxi); > + ctxi = NULL; > +err2: > + /* > + * Here, we're overriding the fops with a dummy all-NULL fops because > + * fput() calls the release fop, which will cause us to mistakenly > + * call into the CXL code. Rather than try to add yet more complexity > + * to that routine (cxlflash_cxl_release) we should try to fix the > + * issue here. > + */ > + file->f_op = &null_fops; > + fput(file); > + put_unused_fd(fd); > + fd = -1; > +err1: > + cxl_release_context(ctx); > +err0: > + kfree(lun_access); > + goto out; > +} > + > +/** > + * cxlflash_manage_lun() - handles lun management activities > + * @sdev: SCSI device associated with LUN. > + * @manage: Manage ioctl data structure. > + * > + * This routine is used to notify the driver about a LUN's WWID and associate > + * SCSI devices (sdev) with a global LUN instance. Additionally it serves to > + * change a LUN's operating mode: legacy or superpipe. > + * > + * Return: 0 on success, -errno on failure > + */ > +static int cxlflash_manage_lun(struct scsi_device *sdev, > + struct dk_cxlflash_manage_lun *manage) > +{ > + int rc = 0; > + struct llun_info *lli = NULL; > + u64 flags = manage->hdr.flags; > + u32 chan = sdev->channel; > + > + lli = lookup_lun(sdev, manage->wwid); > + pr_debug("%s: ENTER: WWID = %016llX%016llX, flags = %016llX li = %p\n", > + __func__, get_unaligned_le64(&manage->wwid[0]), > + get_unaligned_le64(&manage->wwid[8]), > + manage->hdr.flags, lli); > + if (unlikely(!lli)) { > + rc = -ENOMEM; > + goto out; > + } > + > + if (flags & DK_CXLFLASH_MANAGE_LUN_ENABLE_SUPERPIPE) { > + if (lli->newly_created) > + lli->port_sel = CHAN2PORT(chan); > + else > + lli->port_sel = BOTH_PORTS; > + /* Store off lun in unpacked, AFU-friendly format */ > + lli->lun_id[chan] = lun_to_lunid(sdev->lun); > + sdev->hostdata = lli; > + } else if (flags & DK_CXLFLASH_MANAGE_LUN_DISABLE_SUPERPIPE) { > + if (lli->parent->mode != MODE_NONE) > + rc = -EBUSY; > + else > + sdev->hostdata = NULL; > + } > + > +out: > + pr_debug("%s: returning rc=%d\n", __func__, rc); > + return rc; > +} > + > +/** > + * recover_context() - recovers a context in error > + * @cfg: Internal structure associated with the host. > + * @ctxi: Context to release. > + * > + * Restablishes the state for a context-in-error. > + * > + * Return: 0 on success, -errno on failure > + */ > +static int recover_context(struct cxlflash_cfg *cfg, struct ctx_info *ctxi) > +{ > + int rc = 0; > + int old_fd, fd = -1; > + int ctxid = -1; > + struct file *file; > + struct cxl_context *ctx; > + struct afu *afu = cfg->afu; > + > + ctx = cxl_dev_context_init(cfg->dev); > + if (unlikely(IS_ERR_OR_NULL(ctx))) { > + pr_err("%s: Could not initialize context %p\n", __func__, ctx); > + rc = -ENODEV; > + goto out; > + } > + > + ctxid = cxl_process_element(ctx); > + if (unlikely((ctxid > MAX_CONTEXT) || (ctxid < 0))) { > + pr_err("%s: ctxid (%d) invalid!\n", __func__, ctxid); > + rc = -EPERM; > + goto err1; > + } > + > + file = cxl_get_fd(ctx, &cfg->cxl_fops, &fd); > + if (unlikely(fd < 0)) { > + rc = -ENODEV; > + pr_err("%s: Could not get file descriptor\n", __func__); > + goto err1; > + } > + > + rc = cxl_start_work(ctx, &ctxi->work); > + if (unlikely(rc)) { > + pr_err("%s: Could not start context rc=%d\n", __func__, rc); > + goto err2; > + } > + > + /* Update with new MMIO area based on updated context id */ > + ctxi->ctrl_map = &afu->afu_map->ctrls[ctxid].ctrl; > + > + rc = afu_attach(cfg, ctxi); > + if (rc) { > + pr_err("%s: Could not attach AFU rc %d\n", __func__, rc); > + goto err3; > + } > + > + /* > + * No error paths after this point. Once the fd is installed it's > + * visible to user space and can't be undone safely on this thread. > + */ > + old_fd = ctxi->lfd; > + ctxi->ctxid = ENCODE_CTXID(ctxi, ctxid); > + ctxi->lfd = fd; > + ctxi->ctx = ctx; > + ctxi->file = file; > + > + /* > + * Put context back in table (note the reinit of the context list); > + * we must first drop the context's mutex and then acquire it in > + * order with the table/list mutex to avoid a deadlock - safe to do > + * here because no one can find us at this moment in time. > + */ > + mutex_unlock(&ctxi->mutex); > + mutex_lock(&cfg->ctx_tbl_list_mutex); > + mutex_lock(&ctxi->mutex); > + list_del_init(&ctxi->list); > + cfg->ctx_tbl[ctxid] = ctxi; > + mutex_unlock(&cfg->ctx_tbl_list_mutex); > + fd_install(fd, file); > + > + /* Release the original adapter fd and associated CXL resources */ > + sys_close(old_fd); > +out: > + pr_debug("%s: returning ctxid=%d fd=%d rc=%d\n", > + __func__, ctxid, fd, rc); > + return rc; > + > +err3: > + cxl_stop_context(ctx); > +err2: > + fput(file); > + put_unused_fd(fd); > +err1: > + cxl_release_context(ctx); > + goto out; > +} > + > +/** > + * check_state() - checks and responds to the current adapter state > + * @cfg: Internal structure associated with the host. > + * > + * This routine can block and should only be used on process context. > + * Note that when waking up from waiting in limbo, the state is unknown > + * and must be checked again before proceeding. > + * > + * Return: 0 on success, -errno on failure > + */ > +static int check_state(struct cxlflash_cfg *cfg) > +{ > + int rc = 0; > + > +retry: > + switch (cfg->state) { > + case STATE_LIMBO: > + pr_debug("%s: Limbo, going to wait...\n", __func__); > + rc = wait_event_interruptible(cfg->limbo_waitq, > + cfg->state != STATE_LIMBO); > + if (unlikely(rc)) > + goto out; > + goto retry; > + case STATE_FAILTERM: > + pr_debug("%s: Failed/Terminating!\n", __func__); > + rc = -ENODEV; > + goto out; > + default: > + break; > + } > +out: > + return rc; > +} > + > +/** > + * cxlflash_afu_recover() - initiates AFU recovery > + * @sdev: SCSI device associated with LUN. > + * @recover: Recover ioctl data structure. > + * > + * Only a single recovery is allowed at a time to avoid exhausting CXL > + * resources (leading to recovery failure) in the event that we're up > + * against the maximum number of contexts limit. For similar reasons, > + * a context recovery is retried if there are multiple recoveries taking > + * place at the same time and the failure was due to CXL services being > + * unable to keep up. > + * > + * Because a user can detect an error condition before the kernel, it is > + * quite possible for this routine to act as the kernel's EEH detection > + * source (MMIO read of mbox_r). Because of this, there is a window of > + * time where an EEH might have been detected but not yet 'serviced' > + * (callback invoked, causing the device to enter limbo state). To avoid > + * looping in this routine during that window, a 1 second sleep is in place > + * between the time the MMIO failure is detected and the time a wait on the > + * limbo wait queue is attempted via check_state(). > + * > + * Return: 0 on success, -errno on failure > + */ > +static int cxlflash_afu_recover(struct scsi_device *sdev, > + struct dk_cxlflash_recover_afu *recover) > +{ > + struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata; > + struct llun_info *lli = sdev->hostdata; > + struct afu *afu = cfg->afu; > + struct ctx_info *ctxi = NULL; > + struct mutex *mutex = &cfg->ctx_recovery_mutex; > + u64 ctxid = DECODE_CTXID(recover->context_id), > + rctxid = recover->context_id; > + long reg; > + int lretry = 20; /* up to 2 seconds */ > + int rc = 0; > + > + atomic_inc(&cfg->recovery_threads); > + rc = mutex_lock_interruptible(mutex); > + if (rc) > + goto out; > + > + pr_debug("%s: reason 0x%016llX rctxid=%016llX\n", __func__, > + recover->reason, rctxid); > + > +retry: > + /* Ensure that this process is attached to the context */ > + ctxi = get_context(cfg, rctxid, lli, CTX_CTRL_ERR_FALLBACK); > + if (unlikely(!ctxi)) { > + pr_err("%s: Bad context! (%llu)\n", __func__, ctxid); > + rc = -EINVAL; > + goto out; > + } > + > + if (ctxi->err_recovery_active) { > +retry_recover: > + rc = recover_context(cfg, ctxi); > + if (unlikely(rc)) { > + pr_err("%s: Recovery failed for context %llu (rc=%d)\n", > + __func__, ctxid, rc); > + if ((rc == -ENODEV) && > + ((atomic_read(&cfg->recovery_threads) > 1) || > + (lretry--))) { > + pr_debug("%s: Going to try again!\n", __func__); > + mutex_unlock(mutex); > + msleep(100); > + rc = mutex_lock_interruptible(mutex); > + if (rc) > + goto out; > + goto retry_recover; > + } > + > + goto out; > + } > + > + ctxi->err_recovery_active = false; > + recover->context_id = ctxi->ctxid; > + recover->adap_fd = ctxi->lfd; > + recover->mmio_size = sizeof(afu->afu_map->hosts[0].harea); > + recover->hdr.return_flags |= > + DK_CXLFLASH_RECOVER_AFU_CONTEXT_RESET; > + goto out; > + } > + > + /* Test if in error state */ > + reg = readq_be(&afu->ctrl_map->mbox_r); > + if (reg == -1) { > + pr_info("%s: MMIO read fail! Wait for recovery...\n", __func__); > + mutex_unlock(&ctxi->mutex); > + ctxi = NULL; > + ssleep(1); > + rc = check_state(cfg); > + if (unlikely(rc)) > + goto out; > + goto retry; > + } > + > + pr_debug("%s: MMIO working, no recovery required!\n", __func__); > +out: > + if (likely(ctxi)) > + mutex_unlock(&ctxi->mutex); > + mutex_unlock(mutex); > + atomic_dec_if_positive(&cfg->recovery_threads); > + return rc; > +} > + > +/** > + * process_sense() - evaluates and processes sense data > + * @sdev: SCSI device associated with LUN. > + * @verify: Verify ioctl data structure. > + * > + * Return: 0 on success, -errno on failure > + */ > +static int process_sense(struct scsi_device *sdev, > + struct dk_cxlflash_verify *verify) > +{ > + struct llun_info *lli = sdev->hostdata; > + struct glun_info *gli = lli->parent; > + struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata; > + u64 prev_lba = gli->max_lba; > + struct scsi_sense_hdr sshdr = { 0 }; > + int rc = 0; > + > + rc = scsi_normalize_sense((const u8 *)&verify->sense_data, > + DK_CXLFLASH_VERIFY_SENSE_LEN, &sshdr); > + if (!rc) { > + pr_err("%s: Failed to normalize sense data!\n", __func__); > + rc = -EINVAL; > + goto out; > + } > + > + switch (sshdr.sense_key) { > + case NO_SENSE: > + case RECOVERED_ERROR: > + /* fall through */ > + case NOT_READY: > + break; > + case UNIT_ATTENTION: > + switch (sshdr.asc) { > + case 0x29: /* Power on Reset or Device Reset */ > + /* fall through */ > + case 0x2A: /* Device settings/capacity changed */ > + rc = read_cap16(sdev, lli); > + if (rc) { > + rc = -ENODEV; > + break; > + } > + if (prev_lba != gli->max_lba) > + pr_debug("%s: Capacity changed old=%lld " > + "new=%lld\n", __func__, prev_lba, > + gli->max_lba); > + break; > + case 0x3F: /* Report LUNs changed, Rescan. */ > + scsi_scan_host(cfg->host); > + break; > + default: > + rc = -EIO; > + break; > + } > + break; > + default: > + rc = -EIO; > + break; > + } > +out: > + pr_debug("%s: sense_key %x asc %x ascq %x rc %d\n", __func__, > + sshdr.sense_key, sshdr.asc, sshdr.ascq, rc); > + return rc; > +} > + > +/** > + * cxlflash_disk_verify() - verifies a LUN is the same and handle size changes > + * @sdev: SCSI device associated with LUN. > + * @verify: Verify ioctl data structure. > + * > + * Return: 0 on success, -errno on failure > + */ > +static int cxlflash_disk_verify(struct scsi_device *sdev, > + struct dk_cxlflash_verify *verify) > +{ > + int rc = 0; > + struct ctx_info *ctxi = NULL; > + struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata; > + struct llun_info *lli = sdev->hostdata; > + struct glun_info *gli = lli->parent; > + struct sisl_rht_entry *rhte = NULL; > + res_hndl_t rhndl = verify->rsrc_handle; > + u64 ctxid = DECODE_CTXID(verify->context_id), > + rctxid = verify->context_id; > + u64 last_lba = 0; > + > + pr_debug("%s: ctxid=%llu rhndl=%016llX, hint=%016llX, flags=%016llX\n", > + __func__, ctxid, verify->rsrc_handle, verify->hint, > + verify->hdr.flags); > + > + ctxi = get_context(cfg, rctxid, lli, 0); > + if (unlikely(!ctxi)) { > + pr_err("%s: Bad context! (%llu)\n", __func__, ctxid); > + rc = -EINVAL; > + goto out; > + } > + > + rhte = get_rhte(ctxi, rhndl, lli); > + if (unlikely(!rhte)) { > + pr_err("%s: Bad resource handle! (%d)\n", __func__, rhndl); > + rc = -EINVAL; > + goto out; > + } > + > + /* > + * Look at the hint/sense to see if it requires us to redrive > + * inquiry (i.e. the Unit attention is due to the WWN changing). > + */ > + if (verify->hint & DK_CXLFLASH_VERIFY_HINT_SENSE) { > + rc = process_sense(sdev, verify); > + if (unlikely(rc)) { > + pr_err("%s: Failed to validate sense data! (%d)\n", > + __func__, rc); > + goto out; > + } > + } > + > + switch (gli->mode) { > + case MODE_PHYSICAL: > + last_lba = gli->max_lba; > + break; > + default: > + WARN(1, "Unsupported LUN mode!"); > + } > + > + verify->last_lba = last_lba; > + > +out: > + if (likely(ctxi)) > + mutex_unlock(&ctxi->mutex); > + pr_debug("%s: returning rc=%d llba=%llX\n", > + __func__, rc, verify->last_lba); > + return rc; > +} > + > +/** > + * decode_ioctl() - translates an encoded ioctl to an easily identifiable string > + * @cmd: The ioctl command to decode. > + * > + * Return: A string identifying the decoded ioctl. > + */ > +static char *decode_ioctl(int cmd) > +{ > + switch (cmd) { > + case DK_CXLFLASH_ATTACH: > + return __stringify_1(DK_CXLFLASH_ATTACH); > + case DK_CXLFLASH_USER_DIRECT: > + return __stringify_1(DK_CXLFLASH_USER_DIRECT); > + case DK_CXLFLASH_RELEASE: > + return __stringify_1(DK_CXLFLASH_RELEASE); > + case DK_CXLFLASH_DETACH: > + return __stringify_1(DK_CXLFLASH_DETACH); > + case DK_CXLFLASH_VERIFY: > + return __stringify_1(DK_CXLFLASH_VERIFY); > + case DK_CXLFLASH_RECOVER_AFU: > + return __stringify_1(DK_CXLFLASH_RECOVER_AFU); > + case DK_CXLFLASH_MANAGE_LUN: > + return __stringify_1(DK_CXLFLASH_MANAGE_LUN); > + } > + > + return "UNKNOWN"; > +} > + > +/** > + * cxlflash_disk_direct_open() - opens a direct (physical) disk > + * @sdev: SCSI device associated with LUN. > + * @arg: UDirect ioctl data structure. > + * > + * On successful return, the user is informed of the resource handle > + * to be used to identify the direct lun and the size (in blocks) of > + * the direct lun in last LBA format. > + * > + * Return: 0 on success, -errno on failure > + */ > +static int cxlflash_disk_direct_open(struct scsi_device *sdev, void *arg) > +{ > + struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata; > + struct device *dev = &cfg->dev->dev; > + struct afu *afu = cfg->afu; > + struct llun_info *lli = sdev->hostdata; > + struct glun_info *gli = lli->parent; > + > + struct dk_cxlflash_udirect *pphys = (struct dk_cxlflash_udirect *)arg; > + > + u64 ctxid = DECODE_CTXID(pphys->context_id), > + rctxid = pphys->context_id; > + u64 lun_size = 0; > + u64 last_lba = 0; > + u64 rsrc_handle = -1; > + u32 port = CHAN2PORT(sdev->channel); > + > + int rc = 0; > + > + struct ctx_info *ctxi = NULL; > + struct sisl_rht_entry *rhte = NULL; > + > + pr_debug("%s: ctxid=%llu ls=0x%llx\n", __func__, ctxid, lun_size); > + > + rc = cxlflash_lun_attach(gli, MODE_PHYSICAL); > + if (unlikely(rc)) { > + dev_err(dev, "%s: Failed to attach to LUN! (PHYSICAL)\n", Is this going to spam the console from userspace? Same below. > + __func__); > + goto out; > + } > + > + ctxi = get_context(cfg, rctxid, lli, 0); > + if (unlikely(!ctxi)) { > + dev_err(dev, "%s: Bad context! (%llu)\n", __func__, ctxid); > + rc = -EINVAL; > + goto err1; > + } > + > + rhte = rhte_checkout(ctxi, lli); > + if (unlikely(!rhte)) { > + dev_err(dev, "%s: too many opens for this context\n", __func__); > + rc = -EMFILE; /* too many opens */ > + goto err1; > + } > + > + rsrc_handle = (rhte - ctxi->rht_start); > + > + rht_format1(rhte, lli->lun_id[sdev->channel], ctxi->rht_perms, port); > + cxlflash_afu_sync(afu, ctxid, rsrc_handle, AFU_LW_SYNC); > + > + last_lba = gli->max_lba; > + pphys->hdr.return_flags = 0; > + pphys->last_lba = last_lba; > + pphys->rsrc_handle = rsrc_handle; > + > +out: > + if (likely(ctxi)) > + mutex_unlock(&ctxi->mutex); > + pr_debug("%s: returning handle 0x%llx rc=%d llba %lld\n", > + __func__, rsrc_handle, rc, last_lba); > + return rc; > + > +err1: > + cxlflash_lun_detach(gli); > + goto out; > +} > + > +/** > + * ioctl_common() - common IOCTL handler for driver > + * @sdev: SCSI device associated with LUN. > + * @cmd: IOCTL command. > + * > + * Handles common fencing operations that are valid for multiple ioctls. Always > + * allow through ioctls that are cleanup oriented in nature, even when operating > + * in a failed/terminating state. > + * > + * Return: 0 on success, -errno on failure > + */ > +static int ioctl_common(struct scsi_device *sdev, int cmd) > +{ > + struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata; > + struct llun_info *lli = sdev->hostdata; > + int rc = 0; > + > + if (unlikely(!lli)) { > + pr_debug("%s: Unknown LUN\n", __func__); > + rc = -EINVAL; > + goto out; > + } > + > + rc = check_state(cfg); > + if (unlikely(rc) && (cfg->state == STATE_FAILTERM)) { > + switch (cmd) { > + case DK_CXLFLASH_RELEASE: > + case DK_CXLFLASH_DETACH: > + pr_debug("%s: Command override! (%d)\n", __func__, rc); > + rc = 0; > + break; > + } > + } > +out: > + return rc; > +} > + > +/** > + * cxlflash_ioctl() - IOCTL handler for driver > + * @sdev: SCSI device associated with LUN. > + * @cmd: IOCTL command. > + * @arg: Userspace ioctl data structure. > + * > + * Return: 0 on success, -errno on failure > + */ > +int cxlflash_ioctl(struct scsi_device *sdev, int cmd, void __user *arg) > +{ > + typedef int (*sioctl) (struct scsi_device *, void *); > + > + struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata; > + struct afu *afu = cfg->afu; > + struct dk_cxlflash_hdr *hdr; > + char buf[MAX_CXLFLASH_IOCTL_SZ]; why is buf not just a "union cxlflash_ioctls"? > + size_t size = 0; > + bool known_ioctl = false; > + int idx; > + int rc = 0; > + struct Scsi_Host *shost = sdev->host; > + sioctl do_ioctl = NULL; > + > + static const struct { > + size_t size; > + sioctl ioctl; > + } ioctl_tbl[] = { /* NOTE: order matters here */ > + {sizeof(struct dk_cxlflash_attach), (sioctl)cxlflash_disk_attach}, > + {sizeof(struct dk_cxlflash_udirect), cxlflash_disk_direct_open}, > + {sizeof(struct dk_cxlflash_release), (sioctl)cxlflash_disk_release}, > + {sizeof(struct dk_cxlflash_detach), (sioctl)cxlflash_disk_detach}, > + {sizeof(struct dk_cxlflash_verify), (sioctl)cxlflash_disk_verify}, > + {sizeof(struct dk_cxlflash_recover_afu), (sioctl)cxlflash_afu_recover}, > + {sizeof(struct dk_cxlflash_manage_lun), (sioctl)cxlflash_manage_lun}, > + }; > + > + /* Restrict command set to physical support only for internal LUN */ > + if (afu->internal_lun) > + switch (cmd) { > + case DK_CXLFLASH_RELEASE: > + pr_err("%s: %s not supported for lun_mode=%d\n", > + __func__, decode_ioctl(cmd), afu->internal_lun); > + rc = -EINVAL; > + goto cxlflash_ioctl_exit; > + } > + > + switch (cmd) { > + case DK_CXLFLASH_ATTACH: > + case DK_CXLFLASH_USER_DIRECT: > + case DK_CXLFLASH_RELEASE: > + case DK_CXLFLASH_DETACH: > + case DK_CXLFLASH_VERIFY: > + case DK_CXLFLASH_RECOVER_AFU: > + pr_debug("%s: %s (%08X) on dev(%d/%d/%d/%llu)\n", __func__, > + decode_ioctl(cmd), cmd, shost->host_no, sdev->channel, > + sdev->id, sdev->lun); > + rc = ioctl_common(sdev, cmd); > + if (unlikely(rc)) > + goto cxlflash_ioctl_exit; > + > + /* fall through */ > + > + case DK_CXLFLASH_MANAGE_LUN: > + known_ioctl = true; > + idx = _IOC_NR(cmd) - _IOC_NR(DK_CXLFLASH_ATTACH); > + size = ioctl_tbl[idx].size; > + do_ioctl = ioctl_tbl[idx].ioctl; > + > + if (likely(do_ioctl)) > + break; > + > + /* fall through */ > + default: > + rc = -EINVAL; > + goto cxlflash_ioctl_exit; > + } > + > + if (unlikely(copy_from_user(&buf, arg, size))) { > + pr_err("%s: copy_from_user() fail! " > + "size=%lu cmd=%d (%s) arg=%p\n", > + __func__, size, cmd, decode_ioctl(cmd), arg); > + rc = -EFAULT; > + goto cxlflash_ioctl_exit; > + } > + > + hdr = (struct dk_cxlflash_hdr *)&buf; > + if (hdr->version != 0) { > + pr_err("%s: Version %u not supported for %s\n", > + __func__, hdr->version, decode_ioctl(cmd)); > + rc = -EINVAL; > + goto cxlflash_ioctl_exit; > + } Do you advertise this version anywhere? Users just have to call it and fail? You should check hdr->flags are zero incase some new userspace tries to set them. Same for hdr->rsvd. Also, can you do these checks earlier. It seems you've already done a bunch of stuff before here. > + > + rc = do_ioctl(sdev, (void *)&buf); > + if (likely(!rc)) > + if (unlikely(copy_to_user(arg, &buf, size))) { > + pr_err("%s: copy_to_user() fail! " > + "size=%lu cmd=%d (%s) arg=%p\n", > + __func__, size, cmd, decode_ioctl(cmd), arg); > + rc = -EFAULT; > + } > + > + /* fall through to exit */ > + > +cxlflash_ioctl_exit: > + if (unlikely(rc && known_ioctl)) > + pr_err("%s: ioctl %s (%08X) on dev(%d/%d/%d/%llu) " > + "returned rc %d\n", __func__, > + decode_ioctl(cmd), cmd, shost->host_no, > + sdev->channel, sdev->id, sdev->lun, rc); > + else > + pr_debug("%s: ioctl %s (%08X) on dev(%d/%d/%d/%llu) " > + "returned rc %d\n", __func__, decode_ioctl(cmd), > + cmd, shost->host_no, sdev->channel, sdev->id, > + sdev->lun, rc); > + return rc; > +} > + git am complains about this trailing new line. > diff --git a/drivers/scsi/cxlflash/superpipe.h b/drivers/scsi/cxlflash/superpipe.h > new file mode 100644 > index 0000000..030892b > --- /dev/null > +++ b/drivers/scsi/cxlflash/superpipe.h > @@ -0,0 +1,127 @@ > +/* > + * 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 > + > +/* > + * 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_CHUNK_SIZE (1 << MC_RHT_NMASK) /* in LBAs, see mclient.h */ > + > +#define MC_DISCOVERY_TIMEOUT 5 /* 5 secs */ > + > +#define CHAN2PORT(_x) ((_x) + 1) > + > +enum lun_mode { > + MODE_NONE = 0, > + MODE_PHYSICAL > +}; > + > +/* Global (entire driver, spans adapters) lun_info structure */ > +struct glun_info { > + u64 max_lba; /* from read cap(16) */ > + u32 blk_len; /* from read cap(16) */ > + enum lun_mode mode; /* NONE, PHYSICAL */ > + int users; /* Number of users w/ references to LUN */ > + > + u8 wwid[16]; > + > + spinlock_t slock; > + > + struct list_head list; > +}; > + > +/* Local (per-adapter) lun_info structure */ > +struct llun_info { > + u64 lun_id[CXLFLASH_NUM_FC_PORTS]; /* from REPORT_LUNS */ > + u32 lun_index; /* Index in the lun table */ > + u32 host_no; /* host_no from Scsi_host */ > + u32 port_sel; /* What port to use for this LUN */ > + bool newly_created; /* Whether the LUN was just discovered */ > + > + u8 wwid[16]; /* Keep a duplicate copy here? */ > + > + struct glun_info *parent; /* Pointer to entry in global lun structure */ > + struct scsi_device *sdev; > + struct list_head list; > +}; > + > +struct lun_access { > + struct llun_info *lli; > + struct scsi_device *sdev; > + struct list_head list; > +}; > + > +enum ctx_ctrl { > + CTX_CTRL_CLONE = (1 << 1), > + CTX_CTRL_ERR = (1 << 2), > + CTX_CTRL_ERR_FALLBACK = (1 << 3), > + CTX_CTRL_NOPID = (1 << 4), > + CTX_CTRL_FILE = (1 << 5) > +}; > + > +#define ENCODE_CTXID(_ctx, _id) (((((u64)_ctx) & 0xFFFFFFFF0) << 28) | _id) > +#define DECODE_CTXID(_val) (_val & 0xFFFFFFFF) > + > +struct ctx_info { > + struct sisl_ctrl_map *ctrl_map; /* initialized at startup */ > + struct sisl_rht_entry *rht_start; /* 1 page (req'd for alignment), > + alloc/free on attach/detach */ > + u32 rht_out; /* Number of checked out RHT entries */ > + u32 rht_perms; /* User-defined permissions for RHT entries */ > + struct llun_info **rht_lun; /* Mapping of RHT entries to LUNs */ > + > + struct cxl_ioctl_start_work work; > + u64 ctxid; > + int lfd; > + pid_t pid; > + bool unavail; > + bool err_recovery_active; > + struct mutex mutex; /* Context protection */ > + struct cxl_context *ctx; > + struct list_head luns; /* LUNs attached to this context */ > + const struct vm_operations_struct *cxl_mmap_vmops; > + struct file *file; > + struct list_head list; /* Link contexts in error recovery */ > +}; > + > +struct cxlflash_global { > + spinlock_t slock; > + struct list_head gluns;/* list of glun_info structs */ > + struct page *err_page; /* One page of all 0xF for error notification */ > +}; > + > +int cxlflash_disk_release(struct scsi_device *, struct dk_cxlflash_release *); > +int _cxlflash_disk_release(struct scsi_device *, struct ctx_info *, > + struct dk_cxlflash_release *); > + > +int cxlflash_lun_attach(struct glun_info *, enum lun_mode); > +void cxlflash_lun_detach(struct glun_info *); > + > +struct ctx_info *get_context(struct cxlflash_cfg *, u64, void *, enum ctx_ctrl); > + > +struct sisl_rht_entry *get_rhte(struct ctx_info *, res_hndl_t, > + struct llun_info *); > + > +struct sisl_rht_entry *rhte_checkout(struct ctx_info *, struct llun_info *); > +void rhte_checkin(struct ctx_info *, struct sisl_rht_entry *); > + > +#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..f11bdcf > --- /dev/null > +++ b/include/uapi/scsi/cxlflash_ioctl.h > @@ -0,0 +1,139 @@ > +/* > + * 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 and flag definitions CXL Flash 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 */ > +}; > + > +/* > + * Notes: > + * ----- > + * The 'context_id' field of all ioctl structures contains the context > + * identifier for a context in the lower 32-bits (upper 32-bits are not > + * to be used when identifying a context to the AFU). That said, the value > + * in its entirety (all 64-bits) is to be treated as an opaque cookie and > + * should be presented as such when issuing ioctls. > + * > + * For DK_CXLFLASH_ATTACH ioctl, user specifies read/write access > + * permissions via the O_RDONLY, O_WRONLY, and O_RDWR flags defined in > + * the fcntl.h header file. > + */ > +#define DK_CXLFLASH_ATTACH_REUSE_CONTEXT 0x8000000000000000ULL > + > +struct dk_cxlflash_attach { > + struct dk_cxlflash_hdr hdr; /* Common fields */ > + __u64 num_interrupts; /* Requested number of interrupts */ > + __u64 context_id; /* Returned context */ > + __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 */ > + __u64 reserved[8]; /* Reserved for future use */ > +}; > + > +struct dk_cxlflash_detach { > + struct dk_cxlflash_hdr hdr; /* Common fields */ > + __u64 context_id; /* Context to detach */ > + __u64 reserved[8]; /* Reserved for future use */ > +}; > + > +struct dk_cxlflash_udirect { > + struct dk_cxlflash_hdr hdr; /* Common fields */ > + __u64 context_id; /* Context to own physical resources */ > + __u64 rsrc_handle; /* Returned resource handle */ > + __u64 last_lba; /* Returned last LBA on the device */ > + __u64 reserved[8]; /* Reserved for future use */ > +}; > + > +struct dk_cxlflash_release { > + struct dk_cxlflash_hdr hdr; /* Common fields */ > + __u64 context_id; /* Context owning resources */ > + __u64 rsrc_handle; /* Resource handle to release */ > + __u64 reserved[8]; /* Reserved for future use */ > +}; > + > +#define DK_CXLFLASH_VERIFY_SENSE_LEN 18 > +#define DK_CXLFLASH_VERIFY_HINT_SENSE 0x8000000000000000ULL > + > +struct dk_cxlflash_verify { > + struct dk_cxlflash_hdr hdr; /* Common fields */ > + __u64 context_id; /* Context owning resources to verify */ > + __u64 rsrc_handle; /* Resource handle of LUN */ > + __u64 hint; /* Reasons for verify */ > + __u64 last_lba; /* Returned last LBA of device */ > + __u8 sense_data[DK_CXLFLASH_VERIFY_SENSE_LEN]; /* SCSI sense data */ > + __u8 pad[6]; /* Pad to next 8-byte boundary */ > + __u64 reserved[8]; /* Reserved for future use */ > +}; > + > +#define DK_CXLFLASH_RECOVER_AFU_CONTEXT_RESET 0x8000000000000000ULL > + > +struct dk_cxlflash_recover_afu { > + struct dk_cxlflash_hdr hdr; /* Common fields */ > + __u64 reason; /* Reason for recovery request */ > + __u64 context_id; /* Context to recover / updated ID */ > + __u64 mmio_size; /* Returned size of MMIO area */ > + __u64 adap_fd; /* Returned adapter file descriptor */ > + __u64 reserved[8]; /* Reserved for future use */ > +}; > + > +#define DK_CXLFLASH_MANAGE_LUN_WWID_LEN 16 > +#define DK_CXLFLASH_MANAGE_LUN_ENABLE_SUPERPIPE 0x8000000000000000ULL > +#define DK_CXLFLASH_MANAGE_LUN_DISABLE_SUPERPIPE 0x4000000000000000ULL > +#define DK_CXLFLASH_MANAGE_LUN_ALL_PORTS_ACCESSIBLE 0x2000000000000000ULL > + > +struct dk_cxlflash_manage_lun { > + struct dk_cxlflash_hdr hdr; /* Common fields */ > + __u8 wwid[DK_CXLFLASH_MANAGE_LUN_WWID_LEN]; /* Page83 WWID, NAA-6 */ > + __u64 reserved[8]; /* Rsvd, future use */ > +}; > + > +union cxlflash_ioctls { > + struct dk_cxlflash_attach attach; > + struct dk_cxlflash_detach detach; > + struct dk_cxlflash_udirect udirect; > + struct dk_cxlflash_release release; > + struct dk_cxlflash_verify verify; > + struct dk_cxlflash_recover_afu recover_afu; > + struct dk_cxlflash_manage_lun manage_lun; > +}; > + > +#define MAX_CXLFLASH_IOCTL_SZ (sizeof(union cxlflash_ioctls)) > + > + > +#define CXL_MAGIC 0xCA > +#define CXL_IOWR(_n, _s) _IOWR(CXL_MAGIC, _n, struct _s) > + > +#define DK_CXLFLASH_ATTACH CXL_IOWR(0x80, dk_cxlflash_attach) > +#define DK_CXLFLASH_USER_DIRECT CXL_IOWR(0x81, dk_cxlflash_udirect) > +#define DK_CXLFLASH_RELEASE CXL_IOWR(0x84, dk_cxlflash_release) > +#define DK_CXLFLASH_DETACH CXL_IOWR(0x85, dk_cxlflash_detach) > +#define DK_CXLFLASH_VERIFY CXL_IOWR(0x86, dk_cxlflash_verify) > +#define DK_CXLFLASH_RECOVER_AFU CXL_IOWR(0x88, dk_cxlflash_recover_afu) > +#define DK_CXLFLASH_MANAGE_LUN CXL_IOWR(0x89, dk_cxlflash_manage_lun) I'm not sure I'd leave these sparse. What happens if the vlun patches don't get in? > + > +#endif /* ifndef _CXLFLASH_IOCTL_H */ -- 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
