Impressum fc.c
Sprache: C
// SPDX-License-Identifier: GPL-2.0 /* * Copyright ( c ) 2016 Avago Technologies . All rights reserved . #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt#include <linux/module.h>#include <linux/parser.h>#include <uapi/scsi/fc/fc_fs.h>#include <uapi/scsi/fc/fc_els.h>#include <linux/delay.h>#include <linux/overflow.h>#include <linux/blk-cgroup.h>#include "nvme.h" #include "fabrics.h" #include <linux/nvme-fc-driver.h>#include <linux/nvme-fc.h>#include "fc.h" #include <scsi/scsi_transport_fc.h>/* *************************** Data Structures/Defines ****************** */ enum nvme_fc_queue_flags {0 ,#define NVME_FC_DEFAULT_DEV_LOSS_TMO 60 /* seconds */ #define NVME_FC_DEFAULT_RECONNECT_TMO 2 /* delay between reconnects * when connected and a * connection failure . struct nvme_fc_queue {struct nvme_fc_ctrl *ctrl;struct device *dev;struct blk_mq_hw_ctx *hctx;void *lldd_handle;unsigned long flags;sizeof (u64)); /* alignment for other things alloc'd with */ enum nvme_fcop_flags {1 << 0 ),1 << 1 ),struct nvmefc_ls_req_op {struct nvmefc_ls_req ls_req;struct nvme_fc_rport *rport;struct nvme_fc_queue *queue;struct request *rq;int ls_error;struct completion ls_done;struct list_head lsreq_list; /* rport->ls_req_list */ bool req_queued;struct nvmefc_ls_rcv_op {struct nvme_fc_rport *rport;struct nvmefc_ls_rsp *lsrsp;union nvmefc_ls_requests *rqstbuf;union nvmefc_ls_responses *rspbuf;bool handled;struct list_head lsrcv_list; /* rport->ls_rcv_list */ sizeof (u64)); /* alignment for other things alloc'd with */ enum nvme_fcpop_state {0 ,1 ,2 ,3 ,4 ,struct nvme_fc_fcp_op {struct nvme_request nreq; /* * nvme / host / core . c * requires this to be * the 1 st element in the * private structure * associated with the * request . struct nvmefc_fcp_req fcp_req;struct nvme_fc_ctrl *ctrl;struct nvme_fc_queue *queue;struct request *rq;struct nvme_fc_cmd_iu cmd_iu;struct nvme_fc_ersp_iu rsp_iu;struct nvme_fcp_op_w_sgl {struct nvme_fc_fcp_op op;struct scatterlist sgl[NVME_INLINE_SG_CNT];struct nvme_fc_lport {struct nvme_fc_local_port localport;struct ida endp_cnt;struct list_head port_list; /* nvme_fc_port_list */ struct list_head endp_list;struct device *dev; /* physical device for dma */ struct nvme_fc_port_template *ops;struct kref ref;sizeof (u64)); /* alignment for other things alloc'd with */ struct nvme_fc_rport {struct nvme_fc_remote_port remoteport;struct list_head endp_list; /* for lport->endp_list */ struct list_head ctrl_list;struct list_head ls_req_list;struct list_head ls_rcv_list;struct list_head disc_list;struct device *dev; /* physical device for dma */ struct nvme_fc_lport *lport;struct kref ref;unsigned long dev_loss_end;struct work_struct lsrcv_work;sizeof (u64)); /* alignment for other things alloc'd with */ /* fc_ctrl flags values - specified as bit positions */ #define ASSOC_ACTIVE 0 #define ASSOC_FAILED 1 #define FCCTRL_TERMIO 2 struct nvme_fc_ctrl {struct nvme_fc_queue *queues;struct device *dev;struct nvme_fc_lport *lport;struct nvme_fc_rport *rport;bool ioq_live;struct nvmefc_ls_rcv_op *rcv_disconn;struct list_head ctrl_list; /* rport->ctrl_list */ struct blk_mq_tag_set admin_tag_set;struct blk_mq_tag_set tag_set;struct work_struct ioerr_work;struct delayed_work connect_work;struct kref ref;unsigned long flags;struct nvme_fc_fcp_op aen_ops[NVME_NR_AEN_COMMANDS];struct nvme_ctrl ctrl;static inline struct nvme_fc_ctrl *struct nvme_ctrl *ctrl)return container_of(ctrl, struct nvme_fc_ctrl, ctrl);static inline struct nvme_fc_lport *struct nvme_fc_local_port *portptr)return container_of(portptr, struct nvme_fc_lport, localport);static inline struct nvme_fc_rport *struct nvme_fc_remote_port *portptr)return container_of(portptr, struct nvme_fc_rport, remoteport);static inline struct nvmefc_ls_req_op *struct nvmefc_ls_req *lsreq)return container_of(lsreq, struct nvmefc_ls_req_op, ls_req);static inline struct nvme_fc_fcp_op *struct nvmefc_fcp_req *fcpreq)return container_of(fcpreq, struct nvme_fc_fcp_op, fcp_req);/* *************************** Globals **************************** */ static DEFINE_SPINLOCK(nvme_fc_lock);static LIST_HEAD(nvme_fc_lport_list);static DEFINE_IDA(nvme_fc_local_port_cnt);static DEFINE_IDA(nvme_fc_ctrl_cnt);/* * These items are short - term . They will eventually be moved into * a generic FC class . See comments in module init . static struct device *fc_udev_device;static void nvme_fc_complete_rq(struct request *rq);/* *********************** FC-NVME Port Management ************************ */ static void __nvme_fc_delete_hw_queue(struct nvme_fc_ctrl *,struct nvme_fc_queue *, unsigned int );static void nvme_fc_handle_ls_rqst_work(struct work_struct *work);static void struct kref *ref)struct nvme_fc_lport *lport =struct nvme_fc_lport, ref);unsigned long flags;/* remove from transport list */ static void struct nvme_fc_lport *lport)static int struct nvme_fc_lport *lport)return kref_get_unless_zero(&lport->ref);static struct nvme_fc_lport *struct nvme_fc_port_info *pinfo,struct nvme_fc_port_template *ops,struct device *dev)struct nvme_fc_lport *lport;unsigned long flags;if (lport->localport.node_name != pinfo->node_name ||continue ;if (lport->dev != dev) {goto out_done;if (lport->localport.port_state != FC_OBJSTATE_DELETED) {goto out_done;if (!nvme_fc_lport_get(lport)) {/* * fails if ref cnt already 0 . If so , * act as if lport already deleted goto out_done;/* resume the lport */ return lport;return lport;/** * nvme_fc_register_localport - transport entry point called by an * LLDD to register the existence of a NVME * host FC port . * @ pinfo : pointer to information about the port to be registered * @ template : LLDD entrypoints and operational parameters for the port * @ dev : physical hardware device node port corresponds to . Will be * used for DMA mappings * @ portptr : pointer to a local port pointer . Upon success , the routine * will allocate a nvme_fc_local_port structure and place its * address in the local port pointer . Upon failure , local port * pointer will be set to 0 . * * Returns : * a completion status . Must be 0 upon success ; a negative errno * ( ex : - ENXIO ) upon failure . int struct nvme_fc_port_info *pinfo,struct nvme_fc_port_template *template ,struct device *dev,struct nvme_fc_local_port **portptr)struct nvme_fc_lport *newrec;unsigned long flags;int ret, idx;if (!template ->localport_delete || !template ->remoteport_delete ||template ->ls_req || !template ->fcp_io ||template ->ls_abort || !template ->fcp_abort ||template ->max_hw_queues || !template ->max_sgl_segments ||template ->max_dif_sgl_segments || !template ->dma_boundary) {goto out_reghost_failed;/* * look to see if there is already a localport that had been * deregistered and in the process of waiting for all the * references to fully be removed . If the references haven ' t * expired , we can simply re - enable the localport . Remoteports * and controller reconnections should resume naturally . template , dev);/* found an lport, but something about its state is bad */ if (IS_ERR(newrec)) {goto out_reghost_failed;/* found existing lport, which was resumed */ else if (newrec) {return 0 ;/* nothing found - allocate a new localport struct */ sizeof (*newrec) + template ->local_priv_sz),if (!newrec) {goto out_reghost_failed;if (idx < 0 ) {goto out_fail_kfree;if (!get_device(dev) && dev) {goto out_ida_put;0 );template ;if (template ->local_priv_sz)private = &newrec[1 ];else private = NULL;if (dev)template ->dma_boundary);return 0 ;return ret;/** * nvme_fc_unregister_localport - transport entry point called by an * LLDD to deregister / remove a previously * registered a NVME host FC port . * @ portptr : pointer to the ( registered ) local port that is to be deregistered . * * Returns : * a completion status . Must be 0 upon success ; a negative errno * ( ex : - ENXIO ) upon failure . int struct nvme_fc_local_port *portptr)struct nvme_fc_lport *lport = localport_to_lport(portptr);unsigned long flags;if (!portptr)return -EINVAL;if (portptr->port_state != FC_OBJSTATE_ONLINE) {return -EINVAL;if (atomic_read(&lport->act_rport_cnt) == 0 )return 0 ;/* * TRADDR strings , per FC - NVME are fixed format : * " nn - 0 x < 16 hexdigits > : pn - 0 x < 16 hexdigits > " - 43 characters * udev event will only differ by prefix of what field is * being specified : * " NVMEFC_HOST_TRADDR = " or " NVMEFC_TRADDR = " - 19 max characters * 19 + 43 + null_fudge = 64 characters #define FCNVME_TRADDR_LENGTH 64 static void struct nvme_fc_lport *lport,struct nvme_fc_rport *rport)char hostaddr[FCNVME_TRADDR_LENGTH]; /* NVMEFC_HOST_TRADDR=...*/ char tgtaddr[FCNVME_TRADDR_LENGTH]; /* NVMEFC_TRADDR=...*/ char *envp[4 ] = { "FC_EVENT=nvmediscovery" , hostaddr, tgtaddr, NULL };if (!(rport->remoteport.port_role & FC_PORT_ROLE_NVME_DISCOVERY))return ;sizeof (hostaddr),"NVMEFC_HOST_TRADDR=nn-0x%016llx:pn-0x%016llx" ,sizeof (tgtaddr),"NVMEFC_TRADDR=nn-0x%016llx:pn-0x%016llx" ,static void struct kref *ref)struct nvme_fc_rport *rport =struct nvme_fc_rport, ref);struct nvme_fc_lport *lport =unsigned long flags;/* remove from lport list */ static void struct nvme_fc_rport *rport)static int struct nvme_fc_rport *rport)return kref_get_unless_zero(&rport->ref);static void struct nvme_fc_ctrl *ctrl)switch (nvme_ctrl_state(&ctrl->ctrl)) {case NVME_CTRL_NEW:case NVME_CTRL_CONNECTING:/* * As all reconnects were suppressed , schedule a * connect . "NVME-FC{%d}: connectivity re-established. " "Attempting reconnect\n" , ctrl->cnum);0 );break ;case NVME_CTRL_RESETTING:/* * Controller is already in the process of terminating the * association . No need to do anything further . The reconnect * step will naturally occur after the reset completes . break ;default :/* no action to take - let it delete */ break ;static struct nvme_fc_rport *struct nvme_fc_lport *lport,struct nvme_fc_port_info *pinfo)struct nvme_fc_rport *rport;struct nvme_fc_ctrl *ctrl;unsigned long flags;if (rport->remoteport.node_name != pinfo->node_name ||continue ;if (!nvme_fc_rport_get(rport)) {goto out_done;/* has it been unregistered */ if (rport->remoteport.port_state != FC_OBJSTATE_DELETED) {/* means lldd called us twice */ return ERR_PTR(-ESTALE);0 ;/* * kick off a reconnect attempt on all associations to the * remote port . A successful reconnects will resume i / o . return rport;return rport;static inline void struct nvme_fc_rport *rport,struct nvme_fc_port_info *pinfo)if (pinfo->dev_loss_tmo)else /** * nvme_fc_register_remoteport - transport entry point called by an * LLDD to register the existence of a NVME * subsystem FC port on its fabric . * @ localport : pointer to the ( registered ) local port that the remote * subsystem port is connected to . * @ pinfo : pointer to information about the port to be registered * @ portptr : pointer to a remote port pointer . Upon success , the routine * will allocate a nvme_fc_remote_port structure and place its * address in the remote port pointer . Upon failure , remote port * pointer will be set to 0 . * * Returns : * a completion status . Must be 0 upon success ; a negative errno * ( ex : - ENXIO ) upon failure . int struct nvme_fc_local_port *localport,struct nvme_fc_port_info *pinfo,struct nvme_fc_remote_port **portptr)struct nvme_fc_lport *lport = localport_to_lport(localport);struct nvme_fc_rport *newrec;unsigned long flags;int ret, idx;if (!nvme_fc_lport_get(lport)) {goto out_reghost_failed;/* * look to see if there is already a remoteport that is waiting * for a reconnect ( within dev_loss_tmo ) with the same WWN ' s . * If so , transition to it and reconnect . /* found an rport, but something about its state is bad */ if (IS_ERR(newrec)) {goto out_lport_put;/* found existing rport, which was resumed */ else if (newrec) {return 0 ;/* nothing found - allocate a new remoteport struct */ sizeof (*newrec) + lport->ops->remote_priv_sz),if (!newrec) {goto out_lport_put;if (idx < 0 ) {goto out_kfree_rport;0 );if (lport->ops->remote_priv_sz)private = &newrec[1 ];else private = NULL;return 0 ;return ret;static int struct nvme_fc_rport *rport)struct nvmefc_ls_req_op *lsop;unsigned long flags;if (!(lsop->flags & FCOP_FLAGS_TERMIO)) {goto restart;return 0 ;static void struct nvme_fc_ctrl *ctrl)"NVME-FC{%d}: controller connectivity lost. Awaiting " "Reconnect" , ctrl->cnum);/** * nvme_fc_unregister_remoteport - transport entry point called by an * LLDD to deregister / remove a previously * registered a NVME subsystem FC port . * @ portptr : pointer to the ( registered ) remote port that is to be * deregistered . * * Returns : * a completion status . Must be 0 upon success ; a negative errno * ( ex : - ENXIO ) upon failure . int struct nvme_fc_remote_port *portptr)struct nvme_fc_rport *rport = remoteport_to_rport(portptr);struct nvme_fc_ctrl *ctrl;unsigned long flags;if (!portptr)return -EINVAL;if (portptr->port_state != FC_OBJSTATE_ONLINE) {return -EINVAL;/* if dev_loss_tmo==0, dev loss is immediate */ if (!portptr->dev_loss_tmo) {"NVME-FC{%d}: controller connectivity lost.\n" ,else if (atomic_read(&rport->act_ctrl_cnt) == 0 )/* * release the reference , which will allow , if all controllers * go away , which should only occur after dev_loss_tmo occurs , * for the rport to be torn down . return 0 ;/** * nvme_fc_rescan_remoteport - transport entry point called by an * LLDD to request a nvme device rescan . * @ remoteport : pointer to the ( registered ) remote port that is to be * rescanned . * * Returns : N / A void struct nvme_fc_remote_port *remoteport)struct nvme_fc_rport *rport = remoteport_to_rport(remoteport);int struct nvme_fc_remote_port *portptr,struct nvme_fc_rport *rport = remoteport_to_rport(portptr);unsigned long flags;if (portptr->port_state != FC_OBJSTATE_ONLINE) {return -EINVAL;/* a dev_loss_tmo of 0 (immediate) is allowed to be set */ return 0 ;/* *********************** FC-NVME DMA Handling **************************** */ /* * The fcloop device passes in a NULL device pointer . Real LLD ' s will * pass in a valid device pointer . If NULL is passed to the dma mapping * routines , depending on the platform , it may or may not succeed , and * may crash . * * As such : * Wrap all the dma routines and check the dev pointer . * * If simple mappings ( return just a dma address , we ' ll noop them , * returning a dma address of 0 . * * On more complex mappings ( dma_map_sg ) , a pseudo routine fills * in the scatter list , setting all dma addresses to 0 . static inline dma_addr_tstruct device *dev, void *ptr, size_t size,enum dma_data_direction dir)return dev ? dma_map_single(dev, ptr, size, dir) : (dma_addr_t)0 L;static inline int struct device *dev, dma_addr_t dma_addr)return dev ? dma_mapping_error(dev, dma_addr) : 0 ;static inline void struct device *dev, dma_addr_t addr, size_t size,enum dma_data_direction dir)if (dev)static inline void struct device *dev, dma_addr_t addr, size_t size,enum dma_data_direction dir)if (dev)static inline void struct device *dev, dma_addr_t addr, size_t size,enum dma_data_direction dir)if (dev)/* pseudo dma_map_sg call */ static int struct scatterlist *sg, int nents)struct scatterlist *s;int i;0 || sg[0 ].length == 0 );0 L;#ifdef CONFIG_NEED_SG_DMA_LENGTH#endif return nents;static inline int struct device *dev, struct scatterlist *sg, int nents,enum dma_data_direction dir)return dev ? dma_map_sg(dev, sg, nents, dir) : fc_map_sg(sg, nents);static inline void struct device *dev, struct scatterlist *sg, int nents,enum dma_data_direction dir)if (dev)/* *********************** FC-NVME LS Handling **************************** */ static void nvme_fc_ctrl_put(struct nvme_fc_ctrl *);static int nvme_fc_ctrl_get(struct nvme_fc_ctrl *);static void nvme_fc_error_recovery(struct nvme_fc_ctrl *ctrl, char *errmsg);static void struct nvmefc_ls_req_op *lsop)struct nvme_fc_rport *rport = lsop->rport;struct nvmefc_ls_req *lsreq = &lsop->ls_req;unsigned long flags;if (!lsop->req_queued) {return ;false ;static int struct nvme_fc_rport *rport,struct nvmefc_ls_req_op *lsop,void (*done)(struct nvmefc_ls_req *req, int status))struct nvmefc_ls_req *lsreq = &lsop->ls_req;unsigned long flags;int ret = 0 ;if (rport->remoteport.port_state != FC_OBJSTATE_ONLINE)return -ECONNREFUSED;if (!nvme_fc_rport_get(rport))return -ESHUTDOWN;false ;if (fc_dma_mapping_error(rport->dev, lsreq->rqstdma)) {goto out_putrport;true ;if (ret)goto out_unlink;return 0 ;false ;return ret;static void struct nvmefc_ls_req *lsreq, int status)struct nvmefc_ls_req_op *lsop = ls_req_to_lsop(lsreq);static int struct nvme_fc_rport *rport, struct nvmefc_ls_req_op *lsop)struct nvmefc_ls_req *lsreq = &lsop->ls_req;struct fcnvme_ls_rjt *rjt = lsreq->rspaddr;int ret;if (!ret) {/* * No timeout / not interruptible as we need the struct * to exist until the lldd calls us back . Thus mandate * wait until driver calls back . lldd responsible for * the timeout action if (ret)return ret;/* ACC or RJT payload ? */ if (rjt->w0.ls_cmd == FCNVME_LS_RJT)return -ENXIO;return 0 ;static int struct nvme_fc_rport *rport,struct nvmefc_ls_req_op *lsop,void (*done)(struct nvmefc_ls_req *req, int status))/* don't wait for completion */ return __nvme_fc_send_ls_req(rport, lsop, done);static int struct nvme_fc_ctrl *ctrl,struct nvme_fc_queue *queue, u16 qsize, u16 ersp_ratio)struct nvmefc_ls_req_op *lsop;struct nvmefc_ls_req *lsreq;struct fcnvme_ls_cr_assoc_rqst *assoc_rqst;struct fcnvme_ls_cr_assoc_acc *assoc_acc;unsigned long flags;int ret, fcret = 0 ;sizeof (*lsop) +sizeof (*assoc_rqst) + sizeof (*assoc_acc) +if (!lsop) {"NVME-FC{%d}: send Create Association failed: ENOMEM\n" ,goto out_no_memory;struct fcnvme_ls_cr_assoc_rqst *)&lsop[1 ];struct fcnvme_ls_cr_assoc_acc *)&assoc_rqst[1 ];if (ctrl->lport->ops->lsrqst_priv_sz)private = &assoc_acc[1 ];else private = NULL;sizeof (struct fcnvme_lsdesc_cr_assoc_cmd));sizeof (struct fcnvme_lsdesc_cr_assoc_cmd));1 );/* Linux supports only Dynamic controllers */ 0 xffff);sizeof (assoc_rqst->assoc_cmd.hostnqn));sizeof (assoc_rqst->assoc_cmd.subnqn));sizeof (*assoc_rqst);sizeof (*assoc_acc);if (ret)goto out_free_buffer;/* process connect LS completion */ /* validate the ACC response */ if (assoc_acc->hdr.w0.ls_cmd != FCNVME_LS_ACC)else if (assoc_acc->hdr.desc_list_len !=sizeof (struct fcnvme_ls_cr_assoc_acc)))else if (assoc_acc->hdr.rqst.desc_tag !=else if (assoc_acc->hdr.rqst.desc_len !=sizeof (struct fcnvme_lsdesc_rqst)))else if (assoc_acc->hdr.rqst.w0.ls_cmd != FCNVME_LS_CREATE_ASSOCIATION)else if (assoc_acc->associd.desc_tag !=else if (assoc_acc->associd.desc_len !=sizeof (struct fcnvme_lsdesc_assoc_id)))else if (assoc_acc->connectid.desc_tag !=else if (assoc_acc->connectid.desc_len !=sizeof (struct fcnvme_lsdesc_conn_id)))if (fcret) {"q %d Create Association LS failed: %s\n" ,else {if (ret)"queue %d connect admin queue failed (%d).\n" ,return ret;static int struct nvme_fc_ctrl *ctrl, struct nvme_fc_queue *queue,struct nvmefc_ls_req_op *lsop;struct nvmefc_ls_req *lsreq;struct fcnvme_ls_cr_conn_rqst *conn_rqst;struct fcnvme_ls_cr_conn_acc *conn_acc;int ret, fcret = 0 ;sizeof (*lsop) +sizeof (*conn_rqst) + sizeof (*conn_acc) +if (!lsop) {"NVME-FC{%d}: send Create Connection failed: ENOMEM\n" ,goto out_no_memory;struct fcnvme_ls_cr_conn_rqst *)&lsop[1 ];struct fcnvme_ls_cr_conn_acc *)&conn_rqst[1 ];if (ctrl->lport->ops->lsrqst_priv_sz)private = (void *)&conn_acc[1 ];else private = NULL;sizeof (struct fcnvme_lsdesc_assoc_id) +sizeof (struct fcnvme_lsdesc_cr_conn_cmd));sizeof (struct fcnvme_lsdesc_assoc_id));sizeof (struct fcnvme_lsdesc_cr_conn_cmd));1 );sizeof (*conn_rqst);sizeof (*conn_acc);if (ret)goto out_free_buffer;/* process connect LS completion */ /* validate the ACC response */ if (conn_acc->hdr.w0.ls_cmd != FCNVME_LS_ACC)else if (conn_acc->hdr.desc_list_len !=sizeof (struct fcnvme_ls_cr_conn_acc)))else if (conn_acc->hdr.rqst.desc_tag != cpu_to_be32(FCNVME_LSDESC_RQST))else if (conn_acc->hdr.rqst.desc_len !=sizeof (struct fcnvme_lsdesc_rqst)))else if (conn_acc->hdr.rqst.w0.ls_cmd != FCNVME_LS_CREATE_CONNECTION)else if (conn_acc->connectid.desc_tag !=else if (conn_acc->connectid.desc_len !=sizeof (struct fcnvme_lsdesc_conn_id)))if (fcret) {"q %d Create I/O Connection LS failed: %s\n" ,else {if (ret)"queue %d connect I/O queue failed (%d).\n" ,return ret;static void struct nvmefc_ls_req *lsreq, int status)struct nvmefc_ls_req_op *lsop = ls_req_to_lsop(lsreq);/* fc-nvme initiator doesn't care about success or failure of cmd */ /* * This routine sends a FC - NVME LS to disconnect ( aka terminate ) * the FC - NVME Association . Terminating the association also * terminates the FC - NVME connections ( per queue , both admin and io * queues ) that are part of the association . E . g . things are torn * down , and the related FC - NVME Association ID and Connection IDs * become invalid . * * The behavior of the fc - nvme initiator is such that its * understanding of the association and connections will implicitly * be torn down . The action is implicit as it may be due to a loss of * connectivity with the fc - nvme target , so you may never get a * response even if you tried . As such , the action of this routine * is to asynchronously send the LS , ignore any results of the LS , and * continue on with terminating the association . If the fc - nvme target * is present and receives the LS , it too can tear down . static void struct nvme_fc_ctrl *ctrl)struct fcnvme_ls_disconnect_assoc_rqst *discon_rqst;struct fcnvme_ls_disconnect_assoc_acc *discon_acc;struct nvmefc_ls_req_op *lsop;struct nvmefc_ls_req *lsreq;int ret;sizeof (*lsop) +sizeof (*discon_rqst) + sizeof (*discon_acc) +if (!lsop) {"NVME-FC{%d}: send Disconnect Association " "failed: ENOMEM\n" ,return ;struct fcnvme_ls_disconnect_assoc_rqst *)&lsop[1 ];struct fcnvme_ls_disconnect_assoc_acc *)&discon_rqst[1 ];if (ctrl->lport->ops->lsrqst_priv_sz)private = (void *)&discon_acc[1 ];else private = NULL;if (ret)static void struct nvmefc_ls_rcv_op *lsop)struct nvme_fc_rport *rport = lsop->rport;struct nvme_fc_lport *lport = rport->lport;unsigned long flags;sizeof (*lsop->rspbuf), DMA_TO_DEVICE);sizeof (*lsop->rspbuf), DMA_TO_DEVICE);static void struct nvmefc_ls_rsp *lsrsp)struct nvmefc_ls_rcv_op *lsop = lsrsp->nvme_fc_private;static void struct nvmefc_ls_rcv_op *lsop)struct nvme_fc_rport *rport = lsop->rport;struct nvme_fc_lport *lport = rport->lport;struct fcnvme_ls_rqst_w0 *w0 = &lsop->rqstbuf->w0;int ret;sizeof (*lsop->rspbuf), DMA_TO_DEVICE);if (ret) {"LLDD rejected LS RSP xmt: LS %d status %d\n" ,return ;static struct nvme_fc_ctrl *struct nvme_fc_rport *rport,struct nvmefc_ls_rcv_op *lsop)struct fcnvme_ls_disconnect_assoc_rqst *rqst =struct nvme_fc_ctrl *ctrl, *ret = NULL;struct nvmefc_ls_rcv_op *oldls = NULL;unsigned long flags;if (!nvme_fc_ctrl_get(ctrl))continue ;if (association_id == ctrl->association_id) {if (ret)/* leave the ctrl get reference */ break ;/* transmit a response for anything that was pending */ if (oldls) {"NVME-FC{%d}: Multiple Disconnect Association " "LS's received\n" , ctrl->cnum);/* overwrite good response with bogus failure */ sizeof (*oldls->rspbuf),0 );return ret;/* * returns true to mean LS handled and ls_rsp can be sent * returns false to defer ls_rsp xmt ( will be done as part of * association termination ) static bool struct nvmefc_ls_rcv_op *lsop)struct nvme_fc_rport *rport = lsop->rport;struct fcnvme_ls_disconnect_assoc_rqst *rqst =struct fcnvme_ls_disconnect_assoc_acc *acc =struct nvme_fc_ctrl *ctrl = NULL;int ret = 0 ;0 , sizeof (*acc));if (!ret) {/* match an active association */ if (!ctrl)if (ret) {"Disconnect LS failed: %s\n" ,sizeof (*acc), rqst->w0.ls_cmd,0 );return true ;/* format an ACCept response */ sizeof (*acc);sizeof (struct fcnvme_ls_disconnect_assoc_acc)),/* * the transmit of the response will occur after the exchanges * for the association have been ABTS ' d by * nvme_fc_delete_association ( ) . /* fail the association */ "Disconnect Association LS received" );/* release the reference taken by nvme_fc_match_disconn_ls() */ return false ;/* * Actual Processing routine for received FC - NVME LS Requests from the LLD * returns true if a response should be sent afterward , false if rsp will * be sent asynchronously . static bool struct nvmefc_ls_rcv_op *lsop)struct fcnvme_ls_rqst_w0 *w0 = &lsop->rqstbuf->w0;bool ret = true ;/* Be preventative. handlers will later set to valid length */ 0 ;/* * handlers : * parse request input , execute the request , and format the * LS response switch (w0->ls_cmd) {case FCNVME_LS_DISCONNECT_ASSOC:break ;case FCNVME_LS_DISCONNECT_CONN:sizeof (*lsop->rspbuf), w0->ls_cmd,0 );break ;case FCNVME_LS_CREATE_ASSOCIATION:case FCNVME_LS_CREATE_CONNECTION:sizeof (*lsop->rspbuf), w0->ls_cmd,0 );break ;default :sizeof (*lsop->rspbuf), w0->ls_cmd,0 );break ;return (ret);static void struct work_struct *work)struct nvme_fc_rport *rport =struct nvme_fc_rport, lsrcv_work);struct fcnvme_ls_rqst_w0 *w0;struct nvmefc_ls_rcv_op *lsop;unsigned long flags;bool sendrsp;true ;if (lsop->handled)continue ;true ;if (rport->remoteport.port_state == FC_OBJSTATE_ONLINE) {else {sizeof (*lsop->rspbuf),0 );if (sendrsp)goto restart;static void nvme_fc_rcv_ls_req_err_msg(struct nvme_fc_lport *lport,struct fcnvme_ls_rqst_w0 *w0)"RCV %s LS failed: No memory\n" ,"" );/** * nvme_fc_rcv_ls_req - transport entry point called by an LLDD * upon the reception of a NVME LS request . * * The nvme - fc layer will copy payload to an internal structure for * processing . As such , upon completion of the routine , the LLDD may * immediately free / reuse the LS request buffer passed in the call . * * If this routine returns error , the LLDD should abort the exchange . * * @ portptr : pointer to the ( registered ) remote port that the LS * was received from . The remoteport is associated with * a specific localport . * @ lsrsp : pointer to a nvmefc_ls_rsp response structure to be * used to reference the exchange corresponding to the LS * when issuing an ls response . * @ lsreqbuf : pointer to the buffer containing the LS Request * @ lsreqbuf_len : length , in bytes , of the received LS request int struct nvme_fc_remote_port *portptr,struct nvmefc_ls_rsp *lsrsp,void *lsreqbuf, u32 lsreqbuf_len)struct nvme_fc_rport *rport = remoteport_to_rport(portptr);struct nvme_fc_lport *lport = rport->lport;struct fcnvme_ls_rqst_w0 *w0 = (struct fcnvme_ls_rqst_w0 *)lsreqbuf;struct nvmefc_ls_rcv_op *lsop;unsigned long flags;int ret;/* validate there's a routine to transmit a response */ if (!lport->ops->xmt_ls_rsp) {"RCV %s LS failed: no LLDD xmt_ls_rsp\n" ,"" );goto out_put;if (lsreqbuf_len > sizeof (union nvmefc_ls_requests)) {"RCV %s LS failed: payload too large\n" ,"" );goto out_put;sizeof (*lsop), GFP_KERNEL);if (!lsop) {goto out_put;sizeof (*lsop->rqstbuf), GFP_KERNEL);sizeof (*lsop->rspbuf), GFP_KERNEL);if (!lsop->rqstbuf || !lsop->rspbuf) {goto out_free;sizeof (*lsop->rspbuf),if (fc_dma_mapping_error(lport->dev, lsop->rspdma)) {"RCV %s LS failed: DMA mapping failure\n" ,"" );goto out_free;if (rport->remoteport.port_state != FC_OBJSTATE_ONLINE) {goto out_unmap;return 0 ;sizeof (*lsop->rspbuf), DMA_TO_DEVICE);return ret;/* *********************** NVME Ctrl Routines **************************** */ static void struct nvme_fc_ctrl *ctrl,struct nvme_fc_fcp_op *op)sizeof (op->rsp_iu), DMA_FROM_DEVICE);sizeof (op->cmd_iu), DMA_TO_DEVICE);static void struct blk_mq_tag_set *set, struct request *rq,unsigned int hctx_idx)struct nvme_fc_fcp_op *op = blk_mq_rq_to_pdu(rq);return __nvme_fc_exit_request(to_fc_ctrl(set->driver_data), op);static int struct nvme_fc_ctrl *ctrl, struct nvme_fc_fcp_op *op)unsigned long flags;int opstate;if (opstate != FCPOP_STATE_ACTIVE)else if (test_bit(FCCTRL_TERMIO, &ctrl->flags)) {if (opstate != FCPOP_STATE_ACTIVE)return -ECANCELED;return 0 ;static void struct nvme_fc_ctrl *ctrl)struct nvme_fc_fcp_op *aen_op = ctrl->aen_ops;int i;/* ensure we've initialized the ops once */ if (!(aen_op->flags & FCOP_FLAGS_AEN))return ;for (i = 0 ; i < NVME_NR_AEN_COMMANDS; i++, aen_op++)static inline void struct nvme_fc_ctrl *ctrl,struct nvme_fc_fcp_op *op, int opstate)unsigned long flags;if (opstate == FCPOP_STATE_ABORTED) {if (test_bit(FCCTRL_TERMIO, &ctrl->flags) &&if (!--ctrl->iocnt)static void struct work_struct *work)struct nvme_fc_ctrl *ctrl =struct nvme_fc_ctrl, ioerr_work);"transport detected io error" );/* * nvme_fc_io_getuuid - Routine called to get the appid field * associated with request by the lldd * @ req : IO request from nvme fc to driver * Returns : UUID if there is an appid associated with VM or * NULL if the user / libvirt has not set the appid to VM char *nvme_fc_io_getuuid(struct nvmefc_fcp_req *req)struct nvme_fc_fcp_op *op = fcp_req_to_fcp_op(req);struct request *rq = op->rq;if (!IS_ENABLED(CONFIG_BLK_CGROUP_FC_APPID) || !rq || !rq->bio)return NULL;return blkcg_get_fc_appid(rq->bio);static void struct nvmefc_fcp_req *req)struct nvme_fc_fcp_op *op = fcp_req_to_fcp_op(req);struct request *rq = op->rq;struct nvmefc_fcp_req *freq = &op->fcp_req;struct nvme_fc_ctrl *ctrl = op->ctrl;struct nvme_fc_queue *queue = op->queue;struct nvme_completion *cqe = &op->rsp_iu.cqe;struct nvme_command *sqe = &op->cmd_iu.sqe;1 );union nvme_result result;bool terminate_assoc = true ;int opstate;/* * WARNING : * The current linux implementation of a nvme controller * allocates a single tag set for all io queues and sizes * the io queues to fully hold all possible tags . Thus , the * implementation does not reference or care about the sqhd * value as it never needs to use the sqhd / sqtail pointers * for submission pacing . * * This affects the FC - NVME implementation in two ways : * 1 ) As the value doesn ' t matter , we don ' t need to waste * cycles extracting it from ERSPs and stamping it in the * cases where the transport fabricates CQEs on successful * completions . * 2 ) The FC - NVME implementation requires that delivery of * ERSP completions are to go back to the nvme layer in order * relative to the rsn , such that the sqhd value will always * be " in order " for the nvme layer . As the nvme layer in * linux doesn ' t care about sqhd , there ' s no need to return * them in order . * * Additionally : * As the core nvme layer in linux currently does not look at * every field in the cqe - in cases where the FC transport must * fabricate a CQE , the following fields will not be set as they * are not referenced : * cqe . sqid , cqe . sqhd , cqe . command_id * * Failure or error of an individual i / o , in a transport * detected fashion unrelated to the nvme completion status , * potentially cause the initiator and target sides to get out * of sync on SQ head / tail ( aka outstanding io count allowed ) . * Per FC - NVME spec , failure of an individual command requires * the connection to be terminated , which in turn requires the * association to be terminated . sizeof (op->rsp_iu), DMA_FROM_DEVICE);if (opstate == FCPOP_STATE_ABORTED)1 );else if (freq->status) {1 );"NVME-FC{%d}: io failed due to lldd error %d\n" ,/* * For the linux implementation , if we have an unsuccessful * status , the blk - mq layer can typically be called with the * non - zero status and the content of the cqe isn ' t important . if (status)goto done;/* * command completed successfully relative to the wire * protocol . However , validate anything received and * extract the status and result from the cqe ( create it * where necessary ) . switch (freq->rcv_rsplen) {case 0 :case NVME_FC_SIZEOF_ZEROS_RSP:/* * No response payload or 12 bytes of payload ( which * should all be zeros ) are considered successful and * no payload in the CQE by the transport . if (freq->transferred_length !=1 );"NVME-FC{%d}: io failed due to bad transfer " "length: %d vs expected %d\n" ,goto done;0 ;break ;case sizeof (struct nvme_fc_ersp_iu):/* * The ERSP IU contains a full completion with CQE . * Validate ERSP IU and look at cqe . if (unlikely(be16_to_cpu(op->rsp_iu.iu_len) !=4 ) ||1 );"NVME-FC{%d}: io failed due to bad NVMe_ERSP: " "iu len %d, xfr len %d vs %d, status code " "%d, cmdid %d vs %d\n" ,goto done;break ;default :1 );"NVME-FC{%d}: io failed due to odd NVMe_xRSP iu " "len %d\n" ,goto done;false ;if (op->flags & FCOP_FLAGS_AEN) {/* clear other flags */ goto check_error;if (!nvme_try_complete_req(rq, status, result))if (terminate_assoc &&static int struct nvme_fc_ctrl *ctrl,struct nvme_fc_queue *queue, struct nvme_fc_fcp_op *op,struct request *rq, u32 rqno)struct nvme_fcp_op_w_sgl *op_w_sgl =struct nvme_fc_cmd_iu *cmdiu = &op->cmd_iu;int ret = 0 ;0 , sizeof (*op));sizeof (op->cmd_iu);sizeof (op->rsp_iu);sizeof (*cmdiu) / sizeof (u32));if (queue->qnum)0 ,else 0 );sizeof (op->cmd_iu), DMA_TO_DEVICE);if (fc_dma_mapping_error(ctrl->lport->dev, op->fcp_req.cmddma)) {"FCP Op failed - cmdiu dma mapping failed.\n" );goto out_on_error;sizeof (op->rsp_iu),if (fc_dma_mapping_error(ctrl->lport->dev, op->fcp_req.rspdma)) {"FCP Op failed - rspiu dma mapping failed.\n" );return ret;static int struct blk_mq_tag_set *set, struct request *rq,unsigned int hctx_idx, unsigned int numa_node)struct nvme_fc_ctrl *ctrl = to_fc_ctrl(set->driver_data);struct nvme_fcp_op_w_sgl *op = blk_mq_rq_to_pdu(rq);int queue_idx = (set == &ctrl->tag_set) ? hctx_idx + 1 : 0 ;struct nvme_fc_queue *queue = &ctrl->queues[queue_idx];int res;if (res)return res;private = &op->priv[0 ];return res;static int struct nvme_fc_ctrl *ctrl)struct nvme_fc_fcp_op *aen_op;struct nvme_fc_cmd_iu *cmdiu;struct nvme_command *sqe;void *private = NULL;int i, ret;for (i = 0 ; i < NVME_NR_AEN_COMMANDS; i++, aen_op++) {if (ctrl->lport->ops->fcprqst_priv_sz) {private = kzalloc(ctrl->lport->ops->fcprqst_priv_sz,if (!private )return -ENOMEM;0 ],struct request *)NULL,if (ret) {private );return ret;private = private ;0 , sizeof (*sqe));/* Note: core layer may overwrite the sqe.command_id value */ return 0 ;static void struct nvme_fc_ctrl *ctrl)struct nvme_fc_fcp_op *aen_op;int i;for (i = 0 ; i < NVME_NR_AEN_COMMANDS; i++, aen_op++) {private );private = NULL;static inline int struct blk_mq_hw_ctx *hctx, void *data, unsigned int qidx)struct nvme_fc_ctrl *ctrl = to_fc_ctrl(data);struct nvme_fc_queue *queue = &ctrl->queues[qidx];return 0 ;static int struct blk_mq_hw_ctx *hctx, void *data, unsigned int hctx_idx)return __nvme_fc_init_hctx(hctx, data, hctx_idx + 1 );static int struct blk_mq_hw_ctx *hctx, void *data,unsigned int hctx_idx)return __nvme_fc_init_hctx(hctx, data, hctx_idx);static void struct nvme_fc_ctrl *ctrl, int idx)struct nvme_fc_queue *queue;0 , sizeof (*queue));0 );if (idx > 0 )16 ;else sizeof (struct nvme_command);/* * Considered whether we should allocate buffers for all SQEs * and CQEs and dma map them - mapping their respective entries * into the request structures ( kernel vm addr and dma address ) * thus the driver could use the buffers / mappings directly . * It only makes sense if the LLDD would use them for its * messaging api . It ' s very unlikely most adapter api ' s would use * a native NVME sqe / cqe . More reasonable if FC - NVME IU payload * structures were used instead . /* * This routine terminates a queue at the transport level . * The transport has already ensured that all outstanding ios on * the queue have been terminated . * The transport will send a Disconnect LS request to terminate * the queue ' s connection . Termination of the admin queue will also * terminate the association at the target . static void struct nvme_fc_queue *queue)if (!test_and_clear_bit(NVME_FC_Q_CONNECTED, &queue->flags))return ;/* * Current implementation never disconnects a single queue . * It always terminates a whole association . So there is never * a disconnect ( queue ) LS sent to the target . 0 ;0 );static void struct nvme_fc_ctrl *ctrl,struct nvme_fc_queue *queue, unsigned int qidx)if (ctrl->lport->ops->delete_queue)static void struct nvme_fc_ctrl *ctrl)int i;for (i = 1 ; i < ctrl->ctrl.queue_count; i++)static int struct nvme_fc_ctrl *ctrl,struct nvme_fc_queue *queue, unsigned int qidx, u16 qsize)int ret = 0 ;if (ctrl->lport->ops->create_queue)return ret;static void struct nvme_fc_ctrl *ctrl)struct nvme_fc_queue *queue = &ctrl->queues[ctrl->ctrl.queue_count - 1 ];int i;for (i = ctrl->ctrl.queue_count - 1 ; i >= 1 ; i--, queue--)static int struct nvme_fc_ctrl *ctrl, u16 qsize)struct nvme_fc_queue *queue = &ctrl->queues[1 ];int i, ret;for (i = 1 ; i < ctrl->ctrl.queue_count; i++, queue++) {if (ret)goto delete_queues;return 0 ;for (; i > 0 ; i--)return ret;static int struct nvme_fc_ctrl *ctrl, u16 qsize)int i, ret = 0 ;for (i = 1 ; i < ctrl->ctrl.queue_count; i++) {5 ));if (ret)break ;if (ret)break ;return ret;static void struct nvme_fc_ctrl *ctrl)int i;for (i = 1 ; i < ctrl->ctrl.queue_count; i++)static void struct kref *ref)struct nvme_fc_ctrl *ctrl =struct nvme_fc_ctrl, ref);unsigned long flags;if (ctrl->ctrl.tagset)/* remove from rport list */ if (ctrl->ctrl.opts)static void struct nvme_fc_ctrl *ctrl)static int struct nvme_fc_ctrl *ctrl)return kref_get_unless_zero(&ctrl->ref);/* * All accesses from nvme core layer done - can now free the * controller . Called after last nvme_put_ctrl ( ) call static void struct nvme_ctrl *nctrl)struct nvme_fc_ctrl *ctrl = to_fc_ctrl(nctrl);/* * This routine is used by the transport when it needs to find active * io on a queue that is to be terminated . The transport uses * blk_mq_tagset_busy_itr ( ) to find the busy requests , which then invoke * this routine to kill them on a 1 by 1 basis . * * As FC allocates FC exchange for each io , the transport must contact * the LLDD to terminate the exchange , thus releasing the FC exchange . * After terminating the exchange the LLDD will call the transport ' s * normal io done path for the request , but it will have an aborted * status . The done path will return the io request back to the block * layer with an error status . static bool nvme_fc_terminate_exchange(struct request *req, void *data)struct nvme_ctrl *nctrl = data;struct nvme_fc_ctrl *ctrl = to_fc_ctrl(nctrl);struct nvme_fc_fcp_op *op = blk_mq_rq_to_pdu(req);return true ;/* * This routine runs through all outstanding commands on the association * and aborts them . This routine is typically called by the * delete_association routine . It is also called due to an error during * reconnect . In that scenario , it is most likely a command that initializes * the controller , including fabric Connect commands on io queues , that * may have timed out or failed thus the io must be killed for the connect * thread to see the error . static void struct nvme_fc_ctrl *ctrl, bool start_queues)int q;/* * if aborting io , the queues are no longer good , mark them * all as not live . if (ctrl->ctrl.queue_count > 1 ) {for (q = 1 ; q < ctrl->ctrl.queue_count; q++)0 ].flags);/* * If io queues are present , stop them and terminate all outstanding * ios on them . As FC allocates FC exchange for each io , the * transport must contact the LLDD to terminate the exchange , * thus releasing the FC exchange . We use blk_mq_tagset_busy_itr ( ) * to tell us what io ' s are busy and invoke a transport routine * to kill them with the LLDD . After terminating the exchange * the LLDD will call the transport ' s normal io done path , but it * will have an aborted status . The done path will return the * io requests back to the block layer as part of normal completions * ( but with error status ) . if (ctrl->ctrl.queue_count > 1 ) {if (start_queues)/* * Other transports , which don ' t have link - level contexts bound * to sqe ' s , would try to gracefully shutdown the controller by * writing the registers for shutdown and polling ( call * nvme_disable_ctrl ( ) ) . Given a bunch of i / o was potentially * just aborted and we will wait on those contexts , and given * there was no indication of how live the controller is on the * link , don ' t send more io to create more contexts for the * shutdown . Let the controller fail via keepalive failure if * its still present . /* * clean up the admin queue . Same thing as above . if (start_queues)static void struct nvme_fc_ctrl *ctrl, char *errmsg)enum nvme_ctrl_state state = nvme_ctrl_state(&ctrl->ctrl);/* * if an error ( io timeout , etc ) while ( re ) connecting , the remote * port requested terminating of the association ( disconnect_ls ) * or an error ( timeout or abort ) occurred on an io while creating * the controller . Abort any ios on the association and let the * create_association error path resolve things . if (state == NVME_CTRL_CONNECTING) {true );"NVME-FC{%d}: transport error during (re)connect\n" ,return ;/* Otherwise, only proceed if in LIVE state - e.g. on first error */ if (state != NVME_CTRL_LIVE)return ;"NVME-FC{%d}: transport association event: %s\n" ,"NVME-FC{%d}: resetting controller\n" , ctrl->cnum);static enum blk_eh_timer_return nvme_fc_timeout(struct request *rq)struct nvme_fc_fcp_op *op = blk_mq_rq_to_pdu(rq);struct nvme_fc_ctrl *ctrl = op->ctrl;struct nvme_fc_cmd_iu *cmdiu = &op->cmd_iu;struct nvme_command *sqe = &cmdiu->sqe;/* * Attempt to abort the offending command . Command completion * will detect the aborted io and will fail the connection . "NVME-FC{%d.%d}: io timeout: opcode %d fctype %d (%s) w10/11: " "x%08x/x%08x\n" ,if (__nvme_fc_abort_op(ctrl, op))"io timeout abort failed" );/* * the io abort has been initiated . Have the reset timer * restarted and the abort completion will complete the io * shortly . Avoids a synchronous wait while the abort finishes . return BLK_EH_RESET_TIMER;static int struct nvme_fc_ctrl *ctrl, struct request *rq,struct nvme_fc_fcp_op *op)struct nvmefc_fcp_req *freq = &op->fcp_req;int ret;0 ;if (!blk_rq_nr_phys_segments(rq))return 0 ;if (ret)return -ENOMEM;if (unlikely(freq->sg_cnt <= 0 )) {0 ;return -EFAULT;/* * TODO : blk_integrity_rq ( rq ) for DIF return 0 ;static void struct nvme_fc_ctrl *ctrl, struct request *rq,struct nvme_fc_fcp_op *op)struct nvmefc_fcp_req *freq = &op->fcp_req;if (!freq->sg_cnt)return ;0 ;/* * In FC , the queue is a logical thing . At transport connect , the target * creates its " queue " and returns a handle that is to be given to the * target whenever it posts something to the corresponding SQ . When an * SQE is sent on a SQ , FC effectively considers the SQE , or rather the * command contained within the SQE , an io , and assigns a FC exchange * to it . The SQE and the associated SQ handle are sent in the initial * CMD IU sents on the exchange . All transfers relative to the io occur * as part of the exchange . The CQE is the last thing for the io , * which is transferred ( explicitly or implicitly ) with the RSP IU * sent on the exchange . After the CQE is received , the FC exchange is * terminated and the Exchange may be used on a different io . * * The transport to LLDD api has the transport making a request for a * new fcp io request to the LLDD . The LLDD then allocates a FC exchange * resource and transfers the command . The LLDD will then process all * steps to complete the io . Upon completion , the transport done routine * is called . * * So - while the operation is outstanding to the LLDD , there is a link * level FC exchange resource that is also outstanding . This must be * considered in all cleanup operations . static blk_status_tstruct nvme_fc_ctrl *ctrl, struct nvme_fc_queue *queue,struct nvme_fc_fcp_op *op, u32 data_len,enum nvmefc_fcp_datadir io_dir)struct nvme_fc_cmd_iu *cmdiu = &op->cmd_iu;struct nvme_command *sqe = &cmdiu->sqe;int ret, opstate;/* * before attempting to send the io , check to see if we believe * the target device is present if (ctrl->rport->remoteport.port_state != FC_OBJSTATE_ONLINE)return BLK_STS_RESOURCE;if (!nvme_fc_ctrl_get(ctrl))return BLK_STS_IOERR;/* format the FC-NVME CMD IU and fcp_req */ switch (io_dir) {case NVMEFC_FCP_WRITE:break ;case NVMEFC_FCP_READ:break ;case NVMEFC_FCP_NODATA:0 ;break ;0 ;0 ;/* * validate per fabric rules , set fields mandated by fabric spec * as well as those by FC - NVME spec . /* * format SQE DPTR field per FC - NVME rules : * type = 0 x5 Transport SGL Data Block Descriptor * subtype = 0 xA Transport - specific value * address = 0 * length = length of the data series 4 ) |0 ;if (!(op->flags & FCOP_FLAGS_AEN)) {if (ret < 0 ) {if (ret == -ENOMEM || ret == -EAGAIN)return BLK_STS_RESOURCE;return BLK_STS_IOERR;sizeof (op->cmd_iu), DMA_TO_DEVICE);if (!(op->flags & FCOP_FLAGS_AEN))if (ret) {/* * If the lld fails to send the command is there an issue with * the csn value ? If the command that fails is the Connect , * no - as the connection won ' t be live . If it is a command * post - connect , it ' s possible a gap in csn may be created . * Does this matter ? As Linux initiators don ' t send fused * commands , no . The gap would exist , but as there ' s nothing * that depends on csn order to be delivered on the target * side , it shouldn ' t hurt . It would be difficult for a * target to even detect the csn gap as it has no idea when the * cmd with the csn was supposed to arrive . if (!(op->flags & FCOP_FLAGS_AEN)) {if (ctrl->rport->remoteport.port_state == FC_OBJSTATE_ONLINE &&return BLK_STS_IOERR;return BLK_STS_RESOURCE;return BLK_STS_OK;static blk_status_tstruct blk_mq_hw_ctx *hctx,const struct blk_mq_queue_data *bd)struct nvme_ns *ns = hctx->queue->queuedata;struct nvme_fc_queue *queue = hctx->driver_data;struct nvme_fc_ctrl *ctrl = queue->ctrl;struct request *rq = bd->rq;struct nvme_fc_fcp_op *op = blk_mq_rq_to_pdu(rq);enum nvmefc_fcp_datadir io_dir;bool queue_ready = test_bit(NVME_FC_Q_LIVE, &queue->flags);if (ctrl->rport->remoteport.port_state != FC_OBJSTATE_ONLINE ||return nvme_fail_nonready_command(&queue->ctrl->ctrl, rq);if (ret)return ret;/* * nvme core doesn ' t quite treat the rq opaquely . Commands such * as WRITE ZEROES will return a non - zero rq payload_bytes yet * there is no actual payload to be transferred . * To get it right , key data transmission on there being 1 or * more physical segments in the sg list . If there are no * physical segments , there is no payload . if (blk_rq_nr_phys_segments(rq)) {else {0 ;return nvme_fc_start_fcp_op(ctrl, queue, op, data_len, io_dir);static void struct nvme_ctrl *arg)struct nvme_fc_ctrl *ctrl = to_fc_ctrl(arg);struct nvme_fc_fcp_op *aen_op;if (test_bit(FCCTRL_TERMIO, &ctrl->flags))return ;0 ];0 ,if (ret)"failed async event work\n" );static void struct request *rq)struct nvme_fc_fcp_op *op = blk_mq_rq_to_pdu(rq);struct nvme_fc_ctrl *ctrl = op->ctrl;static void nvme_fc_map_queues(struct blk_mq_tag_set *set)struct nvme_fc_ctrl *ctrl = to_fc_ctrl(set->driver_data);int i;for (i = 0 ; i < set->nr_maps; i++) {struct blk_mq_queue_map *map = &set->map[i];if (!map->nr_queues) {continue ;/* Call LLDD map queue functionality if defined */ if (ctrl->lport->ops->map_queues)else static const struct blk_mq_ops nvme_fc_mq_ops = {static int struct nvme_fc_ctrl *ctrl)struct nvmf_ctrl_options *opts = ctrl->ctrl.opts;unsigned int nr_io_queues;int ret;if (ret) {"set_queue_count failed: %d\n" , ret);return ret;1 ;if (!nr_io_queues)return 0 ;1 ,struct nvme_fcp_op_w_sgl, priv,if (ret)return ret;1 );if (ret)goto out_cleanup_tagset;1 );if (ret)goto out_delete_hw_queues;true ;return 0 ;/* force put free routine to ignore io queues */ return ret;static int struct nvme_fc_ctrl *ctrl)struct nvmf_ctrl_options *opts = ctrl->ctrl.opts;1 ;unsigned int nr_io_queues;int ret;if (ret) {"set_queue_count failed: %d\n" , ret);return ret;if (!nr_io_queues && prior_ioq_cnt) {"Fail Reconnect: At least 1 io queue " "required (was %d)\n" , prior_ioq_cnt);return -ENOSPC;1 ;/* check for io queues existing */ if (ctrl->ctrl.queue_count == 1 )return 0 ;if (prior_ioq_cnt != nr_io_queues) {"reconnect: revising io queue count from %d to %d\n" ,1 );if (ret)goto out_free_io_queues;1 );if (ret)goto out_delete_hw_queues;return 0 ;return ret;static void struct nvme_fc_rport *rport)struct nvme_fc_lport *lport = rport->lport;static void struct nvme_fc_rport *rport)struct nvme_fc_lport *lport = rport->lport;if (cnt == 0 && lport->localport.port_state == FC_OBJSTATE_DELETED)static int struct nvme_fc_ctrl *ctrl)struct nvme_fc_rport *rport = ctrl->rport;if (test_and_set_bit(ASSOC_ACTIVE, &ctrl->flags))return 1 ;if (cnt == 1 )return 0 ;static int struct nvme_fc_ctrl *ctrl)struct nvme_fc_rport *rport = ctrl->rport;struct nvme_fc_lport *lport = rport->lport;/* clearing of ctrl->flags ASSOC_ACTIVE bit is in association delete */ if (cnt == 0 ) {if (rport->remoteport.port_state == FC_OBJSTATE_DELETED)return 0 ;/* * This routine restarts the controller on the host side , and * on the link side , recreates the controller association . static int struct nvme_fc_ctrl *ctrl)struct nvmf_ctrl_options *opts = ctrl->ctrl.opts;struct nvmefc_ls_rcv_op *disls = NULL;unsigned long flags;int ret;if (ctrl->rport->remoteport.port_state != FC_OBJSTATE_ONLINE) {return -ENODEV;if (nvme_fc_ctlr_active_on_rport(ctrl)) {return -ENOTUNIQ;"NVME-FC{%d}: create association : host wwpn 0x%016llx " " rport wwpn 0x%016llx: NQN \" %s\"\n" ,/* * Create the admin queue 0 ], 0 ,if (ret)goto out_free_queue;0 ],4 ));if (ret)goto out_delete_hw_queue;if (ret)goto out_disconnect_admin_queue;0 ].flags);/* * Check controller capabilities * * todo : - add code to check if ctrl attributes changed from * prior connection values if (!ret && test_bit(ASSOC_FAILED, &ctrl->flags))if (ret)goto out_disconnect_admin_queue;9 );false );if (ret)goto out_disconnect_admin_queue;if (test_bit(ASSOC_FAILED, &ctrl->flags)) {goto out_stop_keep_alive;/* sanity checks */ /* FC-NVME does not have other data in the capsule */ if (ctrl->ctrl.icdoff) {"icdoff %d is not supported!\n" ,goto out_stop_keep_alive;/* FC-NVME supports normal SGL Data Block Descriptors */ if (!nvme_ctrl_sgl_supported(&ctrl->ctrl)) {"Mandatory sgls are not supported!\n" );goto out_stop_keep_alive;if (opts->queue_size > ctrl->ctrl.maxcmd) {/* warn if maxcmd is lower than queue_size */ "queue_size %zu > ctrl maxcmd %u, reducing " "to maxcmd\n" ,1 ;if (ret)goto out_term_aen_ops;/* * Create the io queues if (ctrl->ctrl.queue_count > 1 ) {if (!ctrl->ioq_live)else if (!ret && test_bit(ASSOC_FAILED, &ctrl->flags))if (ret)goto out_term_aen_ops;if (!nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_LIVE)) {goto out_term_aen_ops;0 ;return 0 ; /* Success */ "NVME-FC{%d}: create_assoc failed, assoc_id %llx ret %d\n" ,/* send a Disconnect(association) LS to fc-nvme target */ 0 ;if (disls)0 ], 0 );0 ]);return ret;/* * This routine stops operation of the controller on the host side . * On the host os stack side : Admin and IO queues are stopped , * outstanding ios on them terminated via FC ABTS . * On the link side : the association is terminated . static void struct nvme_fc_ctrl *ctrl)struct nvmefc_ls_rcv_op *disls = NULL;unsigned long flags;if (!test_and_clear_bit(ASSOC_ACTIVE, &ctrl->flags))return ;0 ;false );/* kill the aens as they are a separate path */ /* wait for all io that had to be aborted */ 0 , ctrl->lock);/* * send a Disconnect ( association ) LS to fc - nvme target * Note : could have been sent at top of process , but * cleaner on link traffic if after the aborts complete . * Note : if association doesn ' t exist , association_id will be 0 if (ctrl->association_id)0 ;if (disls)/* * if a Disconnect Request was waiting for a response , send * now that all ABTS ' s have been issued ( and are complete ) . if (ctrl->ctrl.tagset) {0 ], 0 );0 ]);/* re-enable the admin_q so anything new can fast fail */ /* resume the io queues so that things will fast fail */ static void struct nvme_ctrl *nctrl)struct nvme_fc_ctrl *ctrl = to_fc_ctrl(nctrl);/* * kill the association on the link side . this will block * waiting for io to terminate static void struct nvme_fc_ctrl *ctrl, int status)struct nvme_fc_rport *rport = ctrl->rport;struct nvme_fc_remote_port *portptr = &rport->remoteport;unsigned long recon_delay = ctrl->ctrl.opts->reconnect_delay * HZ;bool recon = true ;if (nvme_ctrl_state(&ctrl->ctrl) != NVME_CTRL_CONNECTING)return ;if (portptr->port_state == FC_OBJSTATE_ONLINE) {"NVME-FC{%d}: reset: Reconnect attempt failed (%d)\n" ,else if (time_after_eq(jiffies, rport->dev_loss_end))false ;if (recon && nvmf_should_reconnect(&ctrl->ctrl, status)) {if (portptr->port_state == FC_OBJSTATE_ONLINE)"NVME-FC{%d}: Reconnect attempt in %ld " "seconds\n" ,else if (time_after(jiffies + recon_delay, rport->dev_loss_end))else {if (portptr->port_state == FC_OBJSTATE_ONLINE) {if (status > 0 && (status & NVME_STATUS_DNR))"NVME-FC{%d}: reconnect failure\n" ,else "NVME-FC{%d}: Max reconnect attempts " "(%d) reached.\n" ,else "NVME-FC{%d}: dev_loss_tmo (%d) expired " "while waiting for remoteport connectivity.\n" ,int , portptr->dev_loss_tmo,static void struct work_struct *work)struct nvme_fc_ctrl *ctrl =struct nvme_fc_ctrl, ctrl.reset_work);/* will block will waiting for io to terminate */ if (!nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_CONNECTING))"NVME-FC{%d}: error_recovery: Couldn't change state " "to CONNECTING\n" , ctrl->cnum);if (ctrl->rport->remoteport.port_state == FC_OBJSTATE_ONLINE) {if (!queue_delayed_work(nvme_wq, &ctrl->connect_work, 0 )) {"NVME-FC{%d}: failed to schedule connect " "after reset\n" , ctrl->cnum);else {else {static const struct nvme_ctrl_ops nvme_fc_ctrl_ops = {"fc" ,static void struct work_struct *work)int ret;struct nvme_fc_ctrl *ctrl =struct nvme_fc_ctrl, connect_work);if (ret)else "NVME-FC{%d}: controller connect complete\n" ,static const struct blk_mq_ops nvme_fc_admin_mq_ops = {/* * Fails a controller request if it matches an existing controller * ( association ) with the same tuple : * < Host NQN , Host ID , local FC port , remote FC port , SUBSYS NQN > * * The ports don ' t need to be compared as they are intrinsically * already matched by the port pointers supplied . static bool struct nvme_fc_rport *rport,struct nvmf_ctrl_options *opts)struct nvme_fc_ctrl *ctrl;unsigned long flags;bool found = false ;if (found)break ;return found;static struct nvme_fc_ctrl *struct device *dev, struct nvmf_ctrl_options *opts,struct nvme_fc_lport *lport, struct nvme_fc_rport *rport)struct nvme_fc_ctrl *ctrl;int ret, idx, ctrl_loss_tmo;if (!(rport->remoteport.port_role &goto out_fail;if (!opts->duplicate_connect &&goto out_fail;sizeof (*ctrl), GFP_KERNEL);if (!ctrl) {goto out_fail;if (idx < 0 ) {goto out_free_ctrl;/* * if ctrl_loss_tmo is being enforced and the default reconnect delay * is being used , change to a shorter reconnect delay for FC . if (opts->max_reconnects != -1 &&0 ;false ;/* io queue count */ unsigned int ,/* +1 for admin queue */ 1 ;0 xffff;sizeof (struct nvme_fc_queue), GFP_KERNEL);if (!ctrl->queues)goto out_free_ida;0 );/* * Would have been nice to init io queues tag set as well . * However , we require interaction from the controller * for max io queue count before we can do so . * Defer this to the connect path . 0 );if (ret)goto out_free_queues;if (lport->dev)return ctrl;/* exit via here doesn't follow ctlr ref points */ return ERR_PTR(ret);static struct nvme_ctrl *struct device *dev, struct nvmf_ctrl_options *opts,struct nvme_fc_lport *lport, struct nvme_fc_rport *rport)struct nvme_fc_ctrl *ctrl;unsigned long flags;int ret;if (IS_ERR(ctrl))return ERR_CAST(ctrl);if (ret)goto out_put_ctrl;struct nvme_fcp_op_w_sgl, priv,if (ret)goto fail_ctrl;if (!nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_CONNECTING)) {"NVME-FC{%d}: failed to init ctrl state\n" , ctrl->cnum);goto fail_ctrl;if (!queue_delayed_work(nvme_wq, &ctrl->connect_work, 0 )) {"NVME-FC{%d}: failed to schedule initial connect\n" ,goto fail_ctrl;"NVME-FC{%d}: new ctrl: NQN \" %s\", hostnqn: %s\n" ,return &ctrl->ctrl;/* initiate nvme ctrl ref counting teardown */ /* Remove core ctrl ref. */ /* as we're past the point where we transition to the ref * counting teardown path , if we return a bad pointer here , * the calling routine , thinking it ' s prior to the * transition , will do an rport put . Since the teardown * path also does a rport put , we do an extra get here to * so proper order / teardown happens . return ERR_PTR(-EIO);struct nvmet_fc_traddr {static int if (match_u64(sstr, &token64))return -EINVAL;return 0 ;/* * This routine validates and extracts the WWN ' s from the TRADDR string . * As kernel parsers need the 0 x to determine number base , universally * build string to parse with 0 x prefix before parsing name strings . static int struct nvmet_fc_traddr *traddr, char *buf, size_t blen)char name[2 + NVME_FC_TRADDR_HEXNAMELEN + 1 ];sizeof (name)-1 ] };int nnoffset, pnoffset;/* validate if string is one of the 2 allowed formats */ if (strnlen(buf, blen) == NVME_FC_TRADDR_MAXLENGTH &&"nn-0x" , NVME_FC_TRADDR_OXNNLEN) &&"pn-0x" , NVME_FC_TRADDR_OXNNLEN)) {else if ((strnlen(buf, blen) == NVME_FC_TRADDR_MINLENGTH &&"nn-" , NVME_FC_TRADDR_NNLEN) &&"pn-" , NVME_FC_TRADDR_NNLEN))) {else goto out_einval;0 ] = '0' ;1 ] = 'x' ;2 + NVME_FC_TRADDR_HEXNAMELEN] = 0 ;2 ], &buf[nnoffset], NVME_FC_TRADDR_HEXNAMELEN);if (__nvme_fc_parse_u64(&wwn, &traddr->nn))goto out_einval;2 ], &buf[pnoffset], NVME_FC_TRADDR_HEXNAMELEN);if (__nvme_fc_parse_u64(&wwn, &traddr->pn))goto out_einval;return 0 ;"%s: bad traddr string\n" , __func__);return -EINVAL;static struct nvme_ctrl *struct device *dev, struct nvmf_ctrl_options *opts)struct nvme_fc_lport *lport;struct nvme_fc_rport *rport;struct nvme_ctrl *ctrl;struct nvmet_fc_traddr laddr = { 0 L, 0 L };struct nvmet_fc_traddr raddr = { 0 L, 0 L };unsigned long flags;int ret;if (ret || !raddr.nn || !raddr.pn)return ERR_PTR(-EINVAL);if (ret || !laddr.nn || !laddr.pn)return ERR_PTR(-EINVAL);/* find the host and remote ports to connect together */ if (lport->localport.node_name != laddr.nn ||continue ;if (rport->remoteport.node_name != raddr.nn ||continue ;/* if fail to get reference fall through. Will error */ if (!nvme_fc_rport_get(rport))break ;if (IS_ERR(ctrl))return ctrl;"%s: %s - %s combination not found\n" ,return ERR_PTR(-ENOENT);static struct nvmf_transport_ops nvme_fc_transport = {"fc" ,/* Arbitrary successive failures max. With lots of subsystems could be high */ #define DISCOVERY_MAX_FAIL 20 static ssize_t nvme_fc_nvme_discovery_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t count)unsigned long flags;struct nvme_fc_lport *lport;struct nvme_fc_rport *rport;int failcnt = 0 ;if (!nvme_fc_lport_get(lport))continue ;if (!nvme_fc_rport_get(rport)) {/* * This is a temporary condition . Upon restart * this rport will be gone from the list . * * Revert the lport put and retry . Anything * added to the list already will be skipped ( as * they are no longer list_empty ) . Loops should * resume at rports that were not yet seen . if (failcnt++ < DISCOVERY_MAX_FAIL)goto restart;"nvme_discovery: too many reference " "failures\n" );goto process_local_list;if (list_empty(&rport->disc_list))while (!list_empty(&local_disc_list)) {struct nvme_fc_rport, disc_list);/* signal discovery. Won't hurt if it repeats */ return count;static DEVICE_ATTR(nvme_discovery, 0200 , NULL, nvme_fc_nvme_discovery_store);#ifdef CONFIG_BLK_CGROUP_FC_APPID/* Parse the cgroup id from a buf and return the length of cgrpid */ static int fc_parse_cgrpid(const char *buf, u64 *id)char cgrp_id[16 +1 ];int cgrpid_len, j;0 x0, sizeof (cgrp_id));for (cgrpid_len = 0 , j = 0 ; cgrpid_len < 17 ; cgrpid_len++) {if (buf[cgrpid_len] != ':' )else {1 ;break ;if (!j)return -EINVAL;if (kstrtou64(cgrp_id, 16 , id) < 0 )return -EINVAL;return cgrpid_len;/* * Parse and update the appid in the blkcg associated with the cgroupid . static ssize_t fc_appid_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t count)int appid_len = 0 ;int cgrpid_len = 0 ;char app_id[FC_APPID_LEN];int ret = 0 ;if (buf[count-1 ] == '\n' )if ((count > (16 +1 +FC_APPID_LEN)) || (!strchr(buf, ':' )))return -EINVAL;if (cgrpid_len < 0 )return -EINVAL;1 ;if (appid_len > FC_APPID_LEN)return -EINVAL;0 x0, sizeof (app_id));1 ], appid_len);sizeof (app_id));if (ret < 0 )return ret;return orig_count;static DEVICE_ATTR(appid_store, 0200 , NULL, fc_appid_store);#endif /* CONFIG_BLK_CGROUP_FC_APPID */ static struct attribute *nvme_fc_attrs[] = {#ifdef CONFIG_BLK_CGROUP_FC_APPID#endif static const struct attribute_group nvme_fc_attr_group = {static const struct attribute_group *nvme_fc_attr_groups[] = {static struct class fc_class = {"fc" ,static int __init nvme_fc_init_module(void )int ret;/* * NOTE : * It is expected that in the future the kernel will combine * the FC - isms that are currently under scsi and now being * added to by NVME into a new standalone FC class . The SCSI * and NVME protocols and their devices would be under this * new FC class . * * As we need something to post FC - specific udev events to , * specifically for nvme probe events , start by creating the * new device class . When the new standalone FC class is * put in place , this code will move to a more generic * location for the class . if (ret) {"couldn't register class fc\n" );return ret;/* * Create a device for the FC - centric udev events 0 , 0 ), NULL,"fc_udev_device" );if (IS_ERR(fc_udev_device)) {"couldn't create fc_udev device!\n" );goto out_destroy_class;if (ret)goto out_destroy_device;return 0 ;0 , 0 ));return ret;static void struct nvme_fc_rport *rport)struct nvme_fc_ctrl *ctrl;"NVME-FC{%d}: transport unloading: deleting ctrl\n" ,static void __exit nvme_fc_exit_module(void )struct nvme_fc_lport *lport;struct nvme_fc_rport *rport;unsigned long flags;0 , 0 ));"NVMe host FC transport driver" );"GPL v2" );
Messung V0.5 in Prozent C=97 H=90 G=93
¤ Dauer der Verarbeitung: 0.152 Sekunden
(vorverarbeitet am 2026-10-01)
¤ *© Formatika GbR, Deutschland
2026-10-10
Neuigkeiten Aktuelles Motto des Tages Open Source Software
Jenseits des Üblichen ....
Besucherstatistik
Statistik #Sources=1126864 #Domains=2039723
