[SCSI] iser: handle iscsi_cmd_task rename (2261ec3d) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/infiniband/ulp/iser/iscsi_iser.c

+57 −57

Original line number	Diff line number	Diff line
		@@ -124,33 +124,33 @@ iscsi_iser_recv(struct iscsi_conn *conn,


		/**
		* iscsi_iser_task_init - Initialize ctask
		* @ctask: iscsi ctask
		* iscsi_iser_task_init - Initialize task
		* @task: iscsi task
		*
		* Initialize the ctask for the scsi command or mgmt command.
		* Initialize the task for the scsi command or mgmt command.
		*/
		static int
		iscsi_iser_task_init(struct iscsi_cmd_task *ctask)
		iscsi_iser_task_init(struct iscsi_task *task)
		{
		struct iscsi_iser_conn *iser_conn = ctask->conn->dd_data;
		struct iscsi_iser_cmd_task *iser_ctask = ctask->dd_data;
		struct iscsi_iser_conn *iser_conn = task->conn->dd_data;
		struct iscsi_iser_task *iser_task = task->dd_data;

		/* mgmt ctask */
		if (!ctask->sc) {
		iser_ctask->desc.data = ctask->data;
		/* mgmt task */
		if (!task->sc) {
		iser_task->desc.data = task->data;
		return 0;
		}

		iser_ctask->command_sent = 0;
		iser_ctask->iser_conn = iser_conn;
		iser_ctask_rdma_init(iser_ctask);
		iser_task->command_sent = 0;
		iser_task->iser_conn = iser_conn;
		iser_task_rdma_init(iser_task);
		return 0;
		}

		/**
		* iscsi_iser_mtask_xmit - xmit management(immediate) ctask
		* iscsi_iser_mtask_xmit - xmit management(immediate) task
		* @conn: iscsi connection
		* @ctask: ctask management ctask
		* @task: task management task
		*
		* Notes:
		* The function can return -EAGAIN in which case caller must
		@@ -159,19 +159,19 @@ iscsi_iser_task_init(struct iscsi_cmd_task *ctask)
		*
		**/
		static int
		iscsi_iser_mtask_xmit(struct iscsi_conn conn, struct iscsi_cmd_task ctask)
		iscsi_iser_mtask_xmit(struct iscsi_conn conn, struct iscsi_task task)
		{
		int error = 0;

		debug_scsi("ctask deq [cid %d itt 0x%x]\n", conn->id, ctask->itt);
		debug_scsi("task deq [cid %d itt 0x%x]\n", conn->id, task->itt);

		error = iser_send_control(conn, ctask);
		error = iser_send_control(conn, task);

		/* since iser xmits control with zero copy, ctasks can not be recycled
		/* since iser xmits control with zero copy, tasks can not be recycled
		* right after sending them.
		* The recycling scheme is based on whether a response is expected
		* - if yes, the ctask is recycled at iscsi_complete_pdu
		* - if no, the ctask is recycled at iser_snd_completion
		* - if yes, the task is recycled at iscsi_complete_pdu
		* - if no, the task is recycled at iser_snd_completion
		*/
		if (error && error != -ENOBUFS)
		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
		@@ -181,27 +181,27 @@ iscsi_iser_mtask_xmit(struct iscsi_conn conn, struct iscsi_cmd_task ctask)

		static int
		iscsi_iser_task_xmit_unsol_data(struct iscsi_conn *conn,
		struct iscsi_cmd_task *ctask)
		struct iscsi_task *task)
		{
		struct iscsi_data hdr;
		int error = 0;

		/* Send data-out PDUs while there's still unsolicited data to send */
		while (ctask->unsol_count > 0) {
		iscsi_prep_unsolicit_data_pdu(ctask, &hdr);
		while (task->unsol_count > 0) {
		iscsi_prep_unsolicit_data_pdu(task, &hdr);
		debug_scsi("Sending data-out: itt 0x%x, data count %d\n",
		hdr.itt, ctask->data_count);
		hdr.itt, task->data_count);

		/* the buffer description has been passed with the command */
		/* Send the command */
		error = iser_send_data_out(conn, ctask, &hdr);
		error = iser_send_data_out(conn, task, &hdr);
		if (error) {
		ctask->unsol_datasn--;
		task->unsol_datasn--;
		goto iscsi_iser_task_xmit_unsol_data_exit;
		}
		ctask->unsol_count -= ctask->data_count;
		task->unsol_count -= task->data_count;
		debug_scsi("Need to send %d more as data-out PDUs\n",
		ctask->unsol_count);
		task->unsol_count);
		}

		iscsi_iser_task_xmit_unsol_data_exit:
		@@ -209,37 +209,37 @@ iscsi_iser_task_xmit_unsol_data(struct iscsi_conn *conn,
		}

		static int
		iscsi_iser_task_xmit(struct iscsi_cmd_task *ctask)
		iscsi_iser_task_xmit(struct iscsi_task *task)
		{
		struct iscsi_conn *conn = ctask->conn;
		struct iscsi_iser_cmd_task *iser_ctask = ctask->dd_data;
		struct iscsi_conn *conn = task->conn;
		struct iscsi_iser_task *iser_task = task->dd_data;
		int error = 0;

		if (!ctask->sc)
		return iscsi_iser_mtask_xmit(conn, ctask);
		if (!task->sc)
		return iscsi_iser_mtask_xmit(conn, task);

		if (ctask->sc->sc_data_direction == DMA_TO_DEVICE) {
		BUG_ON(scsi_bufflen(ctask->sc) == 0);
		if (task->sc->sc_data_direction == DMA_TO_DEVICE) {
		BUG_ON(scsi_bufflen(task->sc) == 0);

		debug_scsi("cmd [itt %x total %d imm %d unsol_data %d\n",
		ctask->itt, scsi_bufflen(ctask->sc),
		ctask->imm_count, ctask->unsol_count);
		task->itt, scsi_bufflen(task->sc),
		task->imm_count, task->unsol_count);
		}

		debug_scsi("ctask deq [cid %d itt 0x%x]\n",
		conn->id, ctask->itt);
		debug_scsi("task deq [cid %d itt 0x%x]\n",
		conn->id, task->itt);

		/* Send the cmd PDU */
		if (!iser_ctask->command_sent) {
		error = iser_send_command(conn, ctask);
		if (!iser_task->command_sent) {
		error = iser_send_command(conn, task);
		if (error)
		goto iscsi_iser_task_xmit_exit;
		iser_ctask->command_sent = 1;
		iser_task->command_sent = 1;
		}

		/* Send unsolicited data-out PDU(s) if necessary */
		if (ctask->unsol_count)
		error = iscsi_iser_task_xmit_unsol_data(conn, ctask);
		if (task->unsol_count)
		error = iscsi_iser_task_xmit_unsol_data(conn, task);

		iscsi_iser_task_xmit_exit:
		if (error && error != -ENOBUFS)
		@@ -248,17 +248,17 @@ iscsi_iser_task_xmit(struct iscsi_cmd_task *ctask)
		}

		static void
		iscsi_iser_cleanup_task(struct iscsi_conn conn, struct iscsi_cmd_task ctask)
		iscsi_iser_cleanup_task(struct iscsi_conn conn, struct iscsi_task task)
		{
		struct iscsi_iser_cmd_task *iser_ctask = ctask->dd_data;
		struct iscsi_iser_task *iser_task = task->dd_data;

		/* mgmt tasks do not need special cleanup */
		if (!ctask->sc)
		if (!task->sc)
		return;

		if (iser_ctask->status == ISER_TASK_STATUS_STARTED) {
		iser_ctask->status = ISER_TASK_STATUS_COMPLETED;
		iser_ctask_rdma_finalize(iser_ctask);
		if (iser_task->status == ISER_TASK_STATUS_STARTED) {
		iser_task->status = ISER_TASK_STATUS_COMPLETED;
		iser_task_rdma_finalize(iser_task);
		}
		}

		@@ -408,8 +408,8 @@ iscsi_iser_session_create(struct Scsi_Host *shost,
		struct iscsi_cls_session *cls_session;
		struct iscsi_session *session;
		int i;
		struct iscsi_cmd_task *ctask;
		struct iscsi_iser_cmd_task *iser_ctask;
		struct iscsi_task *task;
		struct iscsi_iser_task *iser_task;

		if (shost) {
		printk(KERN_ERR "iscsi_tcp: invalid shost %d.\n",
		@@ -436,7 +436,7 @@ iscsi_iser_session_create(struct Scsi_Host *shost,
		*/
		cls_session = iscsi_session_setup(&iscsi_iser_transport, shost,
		ISCSI_DEF_XMIT_CMDS_MAX,
		sizeof(struct iscsi_iser_cmd_task),
		sizeof(struct iscsi_iser_task),
		initial_cmdsn);
		if (!cls_session)
		goto remove_host;
		@@ -445,10 +445,10 @@ iscsi_iser_session_create(struct Scsi_Host *shost,
		shost->can_queue = session->scsi_cmds_max;
		/* libiscsi setup itts, data and pool so just set desc fields */
		for (i = 0; i < session->cmds_max; i++) {
		ctask = session->cmds[i];
		iser_ctask = ctask->dd_data;
		ctask->hdr = (struct iscsi_cmd *)&iser_ctask->desc.iscsi_header;
		ctask->hdr_max = sizeof(iser_ctask->desc.iscsi_header);
		task = session->cmds[i];
		iser_task = task->dd_data;
		task->hdr = (struct iscsi_cmd *)&iser_task->desc.iscsi_header;
		task->hdr_max = sizeof(iser_task->desc.iscsi_header);
		}
		return cls_session;

drivers/infiniband/ulp/iser/iscsi_iser.h

+12 −12

Original line number	Diff line number	Diff line
		@@ -173,7 +173,7 @@ struct iser_data_buf {
		/* fwd declarations */
		struct iser_device;
		struct iscsi_iser_conn;
		struct iscsi_iser_cmd_task;
		struct iscsi_iser_task;

		struct iser_mem_reg {
		u32 lkey;
		@@ -197,7 +197,7 @@ struct iser_regd_buf {
		#define MAX_REGD_BUF_VECTOR_LEN 2

		struct iser_dto {
		struct iscsi_iser_cmd_task *ctask;
		struct iscsi_iser_task *task;
		struct iser_conn *ib_conn;
		int notify_enable;

		@@ -265,7 +265,7 @@ struct iscsi_iser_conn {
		rwlock_t lock;
		};

		struct iscsi_iser_cmd_task {
		struct iscsi_iser_task {
		struct iser_desc desc;
		struct iscsi_iser_conn *iser_conn;
		enum iser_task_status status;
		@@ -299,13 +299,13 @@ extern int iser_debug_level;
		int iser_conn_set_full_featured_mode(struct iscsi_conn *conn);

		int iser_send_control(struct iscsi_conn *conn,
		struct iscsi_cmd_task *ctask);
		struct iscsi_task *task);

		int iser_send_command(struct iscsi_conn *conn,
		struct iscsi_cmd_task *ctask);
		struct iscsi_task *task);

		int iser_send_data_out(struct iscsi_conn *conn,
		struct iscsi_cmd_task *ctask,
		struct iscsi_task *task,
		struct iscsi_data *hdr);

		void iscsi_iser_recv(struct iscsi_conn *conn,
		@@ -326,9 +326,9 @@ void iser_rcv_completion(struct iser_desc *desc,

		void iser_snd_completion(struct iser_desc *desc);

		void iser_ctask_rdma_init(struct iscsi_iser_cmd_task *ctask);
		void iser_task_rdma_init(struct iscsi_iser_task *task);

		void iser_ctask_rdma_finalize(struct iscsi_iser_cmd_task *ctask);
		void iser_task_rdma_finalize(struct iscsi_iser_task *task);

		void iser_dto_buffs_release(struct iser_dto *dto);

		@@ -338,10 +338,10 @@ void iser_reg_single(struct iser_device *device,
		struct iser_regd_buf *regd_buf,
		enum dma_data_direction direction);

		void iser_finalize_rdma_unaligned_sg(struct iscsi_iser_cmd_task *ctask,
		void iser_finalize_rdma_unaligned_sg(struct iscsi_iser_task *task,
		enum iser_data_dir cmd_dir);

		int iser_reg_rdma_mem(struct iscsi_iser_cmd_task *ctask,
		int iser_reg_rdma_mem(struct iscsi_iser_task *task,
		enum iser_data_dir cmd_dir);

		int iser_connect(struct iser_conn *ib_conn,
		@@ -361,10 +361,10 @@ int iser_post_send(struct iser_desc *tx_desc);
		int iser_conn_state_comp(struct iser_conn *ib_conn,
		enum iser_ib_conn_state comp);

		int iser_dma_map_task_data(struct iscsi_iser_cmd_task *iser_ctask,
		int iser_dma_map_task_data(struct iscsi_iser_task *iser_task,
		struct iser_data_buf *data,
		enum iser_data_dir iser_dir,
		enum dma_data_direction dma_dir);

		void iser_dma_unmap_task_data(struct iscsi_iser_cmd_task *iser_ctask);
		void iser_dma_unmap_task_data(struct iscsi_iser_task *iser_task);
		#endif

drivers/infiniband/ulp/iser/iser_initiator.c

+95 −95

Original line number	Diff line number	Diff line
		@@ -66,46 +66,46 @@ static void iser_dto_add_regd_buff(struct iser_dto *dto,

		/* Register user buffer memory and initialize passive rdma
		* dto descriptor. Total data size is stored in
		* iser_ctask->data[ISER_DIR_IN].data_len
		* iser_task->data[ISER_DIR_IN].data_len
		*/
		static int iser_prepare_read_cmd(struct iscsi_cmd_task *ctask,
		static int iser_prepare_read_cmd(struct iscsi_task *task,
		unsigned int edtl)

		{
		struct iscsi_iser_cmd_task *iser_ctask = ctask->dd_data;
		struct iscsi_iser_task *iser_task = task->dd_data;
		struct iser_regd_buf *regd_buf;
		int err;
		struct iser_hdr *hdr = &iser_ctask->desc.iser_header;
		struct iser_data_buf *buf_in = &iser_ctask->data[ISER_DIR_IN];
		struct iser_hdr *hdr = &iser_task->desc.iser_header;
		struct iser_data_buf *buf_in = &iser_task->data[ISER_DIR_IN];

		err = iser_dma_map_task_data(iser_ctask,
		err = iser_dma_map_task_data(iser_task,
		buf_in,
		ISER_DIR_IN,
		DMA_FROM_DEVICE);
		if (err)
		return err;

		if (edtl > iser_ctask->data[ISER_DIR_IN].data_len) {
		if (edtl > iser_task->data[ISER_DIR_IN].data_len) {
		iser_err("Total data length: %ld, less than EDTL: "
		"%d, in READ cmd BHS itt: %d, conn: 0x%p\n",
		iser_ctask->data[ISER_DIR_IN].data_len, edtl,
		ctask->itt, iser_ctask->iser_conn);
		iser_task->data[ISER_DIR_IN].data_len, edtl,
		task->itt, iser_task->iser_conn);
		return -EINVAL;
		}

		err = iser_reg_rdma_mem(iser_ctask,ISER_DIR_IN);
		err = iser_reg_rdma_mem(iser_task,ISER_DIR_IN);
		if (err) {
		iser_err("Failed to set up Data-IN RDMA\n");
		return err;
		}
		regd_buf = &iser_ctask->rdma_regd[ISER_DIR_IN];
		regd_buf = &iser_task->rdma_regd[ISER_DIR_IN];

		hdr->flags \|= ISER_RSV;
		hdr->read_stag = cpu_to_be32(regd_buf->reg.rkey);
		hdr->read_va = cpu_to_be64(regd_buf->reg.va);

		iser_dbg("Cmd itt:%d READ tags RKEY:%#.4X VA:%#llX\n",
		ctask->itt, regd_buf->reg.rkey,
		task->itt, regd_buf->reg.rkey,
		(unsigned long long)regd_buf->reg.va);

		return 0;
		@@ -113,43 +113,43 @@ static int iser_prepare_read_cmd(struct iscsi_cmd_task *ctask,

		/* Register user buffer memory and initialize passive rdma
		* dto descriptor. Total data size is stored in
		* ctask->data[ISER_DIR_OUT].data_len
		* task->data[ISER_DIR_OUT].data_len
		*/
		static int
		iser_prepare_write_cmd(struct iscsi_cmd_task *ctask,
		iser_prepare_write_cmd(struct iscsi_task *task,
		unsigned int imm_sz,
		unsigned int unsol_sz,
		unsigned int edtl)
		{
		struct iscsi_iser_cmd_task *iser_ctask = ctask->dd_data;
		struct iscsi_iser_task *iser_task = task->dd_data;
		struct iser_regd_buf *regd_buf;
		int err;
		struct iser_dto *send_dto = &iser_ctask->desc.dto;
		struct iser_hdr *hdr = &iser_ctask->desc.iser_header;
		struct iser_data_buf *buf_out = &iser_ctask->data[ISER_DIR_OUT];
		struct iser_dto *send_dto = &iser_task->desc.dto;
		struct iser_hdr *hdr = &iser_task->desc.iser_header;
		struct iser_data_buf *buf_out = &iser_task->data[ISER_DIR_OUT];

		err = iser_dma_map_task_data(iser_ctask,
		err = iser_dma_map_task_data(iser_task,
		buf_out,
		ISER_DIR_OUT,
		DMA_TO_DEVICE);
		if (err)
		return err;

		if (edtl > iser_ctask->data[ISER_DIR_OUT].data_len) {
		if (edtl > iser_task->data[ISER_DIR_OUT].data_len) {
		iser_err("Total data length: %ld, less than EDTL: %d, "
		"in WRITE cmd BHS itt: %d, conn: 0x%p\n",
		iser_ctask->data[ISER_DIR_OUT].data_len,
		edtl, ctask->itt, ctask->conn);
		iser_task->data[ISER_DIR_OUT].data_len,
		edtl, task->itt, task->conn);
		return -EINVAL;
		}

		err = iser_reg_rdma_mem(iser_ctask,ISER_DIR_OUT);
		err = iser_reg_rdma_mem(iser_task,ISER_DIR_OUT);
		if (err != 0) {
		iser_err("Failed to register write cmd RDMA mem\n");
		return err;
		}

		regd_buf = &iser_ctask->rdma_regd[ISER_DIR_OUT];
		regd_buf = &iser_task->rdma_regd[ISER_DIR_OUT];

		if (unsol_sz < edtl) {
		hdr->flags \|= ISER_WSV;
		@@ -158,13 +158,13 @@ iser_prepare_write_cmd(struct iscsi_cmd_task *ctask,

		iser_dbg("Cmd itt:%d, WRITE tags, RKEY:%#.4X "
		"VA:%#llX + unsol:%d\n",
		ctask->itt, regd_buf->reg.rkey,
		task->itt, regd_buf->reg.rkey,
		(unsigned long long)regd_buf->reg.va, unsol_sz);
		}

		if (imm_sz > 0) {
		iser_dbg("Cmd itt:%d, WRITE, adding imm.data sz: %d\n",
		ctask->itt, imm_sz);
		task->itt, imm_sz);
		iser_dto_add_regd_buff(send_dto,
		regd_buf,
		0,
		@@ -300,13 +300,13 @@ int iser_conn_set_full_featured_mode(struct iscsi_conn *conn)
		}

		static int
		iser_check_xmit(struct iscsi_conn conn, void ctask)
		iser_check_xmit(struct iscsi_conn conn, void task)
		{
		struct iscsi_iser_conn *iser_conn = conn->dd_data;

		if (atomic_read(&iser_conn->ib_conn->post_send_buf_count) ==
		ISER_QP_MAX_REQ_DTOS) {
		iser_dbg("%ld can't xmit ctask %p\n",jiffies,ctask);
		iser_dbg("%ld can't xmit task %p\n",jiffies,task);
		return -ENOBUFS;
		}
		return 0;
		@@ -317,37 +317,37 @@ iser_check_xmit(struct iscsi_conn conn, void ctask)
		* iser_send_command - send command PDU
		*/
		int iser_send_command(struct iscsi_conn *conn,
		struct iscsi_cmd_task *ctask)
		struct iscsi_task *task)
		{
		struct iscsi_iser_conn *iser_conn = conn->dd_data;
		struct iscsi_iser_cmd_task *iser_ctask = ctask->dd_data;
		struct iscsi_iser_task *iser_task = task->dd_data;
		struct iser_dto *send_dto = NULL;
		unsigned long edtl;
		int err = 0;
		struct iser_data_buf *data_buf;

		struct iscsi_cmd *hdr = ctask->hdr;
		struct scsi_cmnd *sc = ctask->sc;
		struct iscsi_cmd *hdr = task->hdr;
		struct scsi_cmnd *sc = task->sc;

		if (!iser_conn_state_comp(iser_conn->ib_conn, ISER_CONN_UP)) {
		iser_err("Failed to send, conn: 0x%p is not up\n", iser_conn->ib_conn);
		return -EPERM;
		}
		if (iser_check_xmit(conn, ctask))
		if (iser_check_xmit(conn, task))
		return -ENOBUFS;

		edtl = ntohl(hdr->data_length);

		/* build the tx desc regd header and add it to the tx desc dto */
		iser_ctask->desc.type = ISCSI_TX_SCSI_COMMAND;
		send_dto = &iser_ctask->desc.dto;
		send_dto->ctask = iser_ctask;
		iser_create_send_desc(iser_conn, &iser_ctask->desc);
		iser_task->desc.type = ISCSI_TX_SCSI_COMMAND;
		send_dto = &iser_task->desc.dto;
		send_dto->task = iser_task;
		iser_create_send_desc(iser_conn, &iser_task->desc);

		if (hdr->flags & ISCSI_FLAG_CMD_READ)
		data_buf = &iser_ctask->data[ISER_DIR_IN];
		data_buf = &iser_task->data[ISER_DIR_IN];
		else
		data_buf = &iser_ctask->data[ISER_DIR_OUT];
		data_buf = &iser_task->data[ISER_DIR_OUT];

		if (scsi_sg_count(sc)) { /* using a scatter list */
		data_buf->buf = scsi_sglist(sc);
		@@ -357,15 +357,15 @@ int iser_send_command(struct iscsi_conn *conn,
		data_buf->data_len = scsi_bufflen(sc);

		if (hdr->flags & ISCSI_FLAG_CMD_READ) {
		err = iser_prepare_read_cmd(ctask, edtl);
		err = iser_prepare_read_cmd(task, edtl);
		if (err)
		goto send_command_error;
		}
		if (hdr->flags & ISCSI_FLAG_CMD_WRITE) {
		err = iser_prepare_write_cmd(ctask,
		ctask->imm_count,
		ctask->imm_count +
		ctask->unsol_count,
		err = iser_prepare_write_cmd(task,
		task->imm_count,
		task->imm_count +
		task->unsol_count,
		edtl);
		if (err)
		goto send_command_error;
		@@ -380,15 +380,15 @@ int iser_send_command(struct iscsi_conn *conn,
		goto send_command_error;
		}

		iser_ctask->status = ISER_TASK_STATUS_STARTED;
		iser_task->status = ISER_TASK_STATUS_STARTED;

		err = iser_post_send(&iser_ctask->desc);
		err = iser_post_send(&iser_task->desc);
		if (!err)
		return 0;

		send_command_error:
		iser_dto_buffs_release(send_dto);
		iser_err("conn %p failed ctask->itt %d err %d\n",conn, ctask->itt, err);
		iser_err("conn %p failed task->itt %d err %d\n",conn, task->itt, err);
		return err;
		}

		@@ -396,11 +396,11 @@ int iser_send_command(struct iscsi_conn *conn,
		* iser_send_data_out - send data out PDU
		*/
		int iser_send_data_out(struct iscsi_conn *conn,
		struct iscsi_cmd_task *ctask,
		struct iscsi_task *task,
		struct iscsi_data *hdr)
		{
		struct iscsi_iser_conn *iser_conn = conn->dd_data;
		struct iscsi_iser_cmd_task *iser_ctask = ctask->dd_data;
		struct iscsi_iser_task *iser_task = task->dd_data;
		struct iser_desc *tx_desc = NULL;
		struct iser_dto *send_dto = NULL;
		unsigned long buf_offset;
		@@ -413,7 +413,7 @@ int iser_send_data_out(struct iscsi_conn *conn,
		return -EPERM;
		}

		if (iser_check_xmit(conn, ctask))
		if (iser_check_xmit(conn, task))
		return -ENOBUFS;

		itt = (__force uint32_t)hdr->itt;
		@@ -434,7 +434,7 @@ int iser_send_data_out(struct iscsi_conn *conn,

		/* build the tx desc regd header and add it to the tx desc dto */
		send_dto = &tx_desc->dto;
		send_dto->ctask = iser_ctask;
		send_dto->task = iser_task;
		iser_create_send_desc(iser_conn, tx_desc);

		iser_reg_single(iser_conn->ib_conn->device,
		@@ -442,15 +442,15 @@ int iser_send_data_out(struct iscsi_conn *conn,

		/* all data was registered for RDMA, we can use the lkey */
		iser_dto_add_regd_buff(send_dto,
		&iser_ctask->rdma_regd[ISER_DIR_OUT],
		&iser_task->rdma_regd[ISER_DIR_OUT],
		buf_offset,
		data_seg_len);

		if (buf_offset + data_seg_len > iser_ctask->data[ISER_DIR_OUT].data_len) {
		if (buf_offset + data_seg_len > iser_task->data[ISER_DIR_OUT].data_len) {
		iser_err("Offset:%ld & DSL:%ld in Data-Out "
		"inconsistent with total len:%ld, itt:%d\n",
		buf_offset, data_seg_len,
		iser_ctask->data[ISER_DIR_OUT].data_len, itt);
		iser_task->data[ISER_DIR_OUT].data_len, itt);
		err = -EINVAL;
		goto send_data_out_error;
		}
		@@ -470,11 +470,11 @@ int iser_send_data_out(struct iscsi_conn *conn,
		}

		int iser_send_control(struct iscsi_conn *conn,
		struct iscsi_cmd_task *ctask)
		struct iscsi_task *task)
		{
		struct iscsi_iser_conn *iser_conn = conn->dd_data;
		struct iscsi_iser_cmd_task *iser_ctask = ctask->dd_data;
		struct iser_desc *mdesc = &iser_ctask->desc;
		struct iscsi_iser_task *iser_task = task->dd_data;
		struct iser_desc *mdesc = &iser_task->desc;
		struct iser_dto *send_dto = NULL;
		unsigned long data_seg_len;
		int err = 0;
		@@ -486,27 +486,27 @@ int iser_send_control(struct iscsi_conn *conn,
		return -EPERM;
		}

		if (iser_check_xmit(conn, ctask))
		if (iser_check_xmit(conn, task))
		return -ENOBUFS;

		/* build the tx desc regd header and add it to the tx desc dto */
		mdesc->type = ISCSI_TX_CONTROL;
		send_dto = &mdesc->dto;
		send_dto->ctask = NULL;
		send_dto->task = NULL;
		iser_create_send_desc(iser_conn, mdesc);

		device = iser_conn->ib_conn->device;

		iser_reg_single(device, send_dto->regd[0], DMA_TO_DEVICE);

		data_seg_len = ntoh24(ctask->hdr->dlength);
		data_seg_len = ntoh24(task->hdr->dlength);

		if (data_seg_len > 0) {
		regd_buf = &mdesc->data_regd_buf;
		memset(regd_buf, 0, sizeof(struct iser_regd_buf));
		regd_buf->device = device;
		regd_buf->virt_addr = ctask->data;
		regd_buf->data_size = ctask->data_count;
		regd_buf->virt_addr = task->data;
		regd_buf->data_size = task->data_count;
		iser_reg_single(device, regd_buf,
		DMA_TO_DEVICE);
		iser_dto_add_regd_buff(send_dto, regd_buf,
		@@ -538,8 +538,8 @@ void iser_rcv_completion(struct iser_desc *rx_desc,
		{
		struct iser_dto *dto = &rx_desc->dto;
		struct iscsi_iser_conn *conn = dto->ib_conn->iser_conn;
		struct iscsi_cmd_task *ctask;
		struct iscsi_iser_cmd_task *iser_ctask;
		struct iscsi_task *task;
		struct iscsi_iser_task *iser_task;
		struct iscsi_hdr *hdr;
		char *rx_data = NULL;
		int rx_data_len = 0;
		@@ -558,16 +558,16 @@ void iser_rcv_completion(struct iser_desc *rx_desc,
		opcode = hdr->opcode & ISCSI_OPCODE_MASK;

		if (opcode == ISCSI_OP_SCSI_CMD_RSP) {
		ctask = iscsi_itt_to_ctask(conn->iscsi_conn, hdr->itt);
		if (!ctask)
		iser_err("itt can't be matched to ctask!!! "
		task = iscsi_itt_to_ctask(conn->iscsi_conn, hdr->itt);
		if (!task)
		iser_err("itt can't be matched to task!!! "
		"conn %p opcode %d itt %d\n",
		conn->iscsi_conn, opcode, hdr->itt);
		else {
		iser_ctask = ctask->dd_data;
		iser_dbg("itt %d ctask %p\n",hdr->itt, ctask);
		iser_ctask->status = ISER_TASK_STATUS_COMPLETED;
		iser_ctask_rdma_finalize(iser_ctask);
		iser_task = task->dd_data;
		iser_dbg("itt %d task %p\n",hdr->itt, task);
		iser_task->status = ISER_TASK_STATUS_COMPLETED;
		iser_task_rdma_finalize(iser_task);
		}
		}
		iser_dto_buffs_release(dto);
		@@ -578,7 +578,7 @@ void iser_rcv_completion(struct iser_desc *rx_desc,
		kmem_cache_free(ig.desc_cache, rx_desc);

		/* decrementing conn->post_recv_buf_count only --after-- freeing the *
		* ctask eliminates the need to worry on ctasks which are completed in *
		* task eliminates the need to worry on tasks which are completed in *
		* parallel to the execution of iser_conn_term. So the code that waits *
		* for the posted rx bufs refcount to become zero handles everything */
		atomic_dec(&conn->ib_conn->post_recv_buf_count);
		@@ -590,7 +590,7 @@ void iser_snd_completion(struct iser_desc *tx_desc)
		struct iser_conn *ib_conn = dto->ib_conn;
		struct iscsi_iser_conn *iser_conn = ib_conn->iser_conn;
		struct iscsi_conn *conn = iser_conn->iscsi_conn;
		struct iscsi_cmd_task *ctask;
		struct iscsi_task *task;
		int resume_tx = 0;

		iser_dbg("Initiator, Data sent dto=0x%p\n", dto);
		@@ -613,31 +613,31 @@ void iser_snd_completion(struct iser_desc *tx_desc)

		if (tx_desc->type == ISCSI_TX_CONTROL) {
		/* this arithmetic is legal by libiscsi dd_data allocation */
		ctask = (void ) ((long)(void )tx_desc -
		sizeof(struct iscsi_cmd_task));
		if (ctask->hdr->itt == RESERVED_ITT)
		iscsi_put_ctask(ctask);
		task = (void ) ((long)(void )tx_desc -
		sizeof(struct iscsi_task));
		if (task->hdr->itt == RESERVED_ITT)
		iscsi_put_task(task);
		}
		}

		void iser_ctask_rdma_init(struct iscsi_iser_cmd_task *iser_ctask)
		void iser_task_rdma_init(struct iscsi_iser_task *iser_task)

		{
		iser_ctask->status = ISER_TASK_STATUS_INIT;
		iser_task->status = ISER_TASK_STATUS_INIT;

		iser_ctask->dir[ISER_DIR_IN] = 0;
		iser_ctask->dir[ISER_DIR_OUT] = 0;
		iser_task->dir[ISER_DIR_IN] = 0;
		iser_task->dir[ISER_DIR_OUT] = 0;

		iser_ctask->data[ISER_DIR_IN].data_len = 0;
		iser_ctask->data[ISER_DIR_OUT].data_len = 0;
		iser_task->data[ISER_DIR_IN].data_len = 0;
		iser_task->data[ISER_DIR_OUT].data_len = 0;

		memset(&iser_ctask->rdma_regd[ISER_DIR_IN], 0,
		memset(&iser_task->rdma_regd[ISER_DIR_IN], 0,
		sizeof(struct iser_regd_buf));
		memset(&iser_ctask->rdma_regd[ISER_DIR_OUT], 0,
		memset(&iser_task->rdma_regd[ISER_DIR_OUT], 0,
		sizeof(struct iser_regd_buf));
		}

		void iser_ctask_rdma_finalize(struct iscsi_iser_cmd_task *iser_ctask)
		void iser_task_rdma_finalize(struct iscsi_iser_task *iser_task)
		{
		int deferred;
		int is_rdma_aligned = 1;
		@@ -646,17 +646,17 @@ void iser_ctask_rdma_finalize(struct iscsi_iser_cmd_task *iser_ctask)
		/* if we were reading, copy back to unaligned sglist,
		* anyway dma_unmap and free the copy
		*/
		if (iser_ctask->data_copy[ISER_DIR_IN].copy_buf != NULL) {
		if (iser_task->data_copy[ISER_DIR_IN].copy_buf != NULL) {
		is_rdma_aligned = 0;
		iser_finalize_rdma_unaligned_sg(iser_ctask, ISER_DIR_IN);
		iser_finalize_rdma_unaligned_sg(iser_task, ISER_DIR_IN);
		}
		if (iser_ctask->data_copy[ISER_DIR_OUT].copy_buf != NULL) {
		if (iser_task->data_copy[ISER_DIR_OUT].copy_buf != NULL) {
		is_rdma_aligned = 0;
		iser_finalize_rdma_unaligned_sg(iser_ctask, ISER_DIR_OUT);
		iser_finalize_rdma_unaligned_sg(iser_task, ISER_DIR_OUT);
		}

		if (iser_ctask->dir[ISER_DIR_IN]) {
		regd = &iser_ctask->rdma_regd[ISER_DIR_IN];
		if (iser_task->dir[ISER_DIR_IN]) {
		regd = &iser_task->rdma_regd[ISER_DIR_IN];
		deferred = iser_regd_buff_release(regd);
		if (deferred) {
		iser_err("%d references remain for BUF-IN rdma reg\n",
		@@ -664,8 +664,8 @@ void iser_ctask_rdma_finalize(struct iscsi_iser_cmd_task *iser_ctask)
		}
		}

		if (iser_ctask->dir[ISER_DIR_OUT]) {
		regd = &iser_ctask->rdma_regd[ISER_DIR_OUT];
		if (iser_task->dir[ISER_DIR_OUT]) {
		regd = &iser_task->rdma_regd[ISER_DIR_OUT];
		deferred = iser_regd_buff_release(regd);
		if (deferred) {
		iser_err("%d references remain for BUF-OUT rdma reg\n",
		@@ -675,7 +675,7 @@ void iser_ctask_rdma_finalize(struct iscsi_iser_cmd_task *iser_ctask)

		/* if the data was unaligned, it was already unmapped and then copied */
		if (is_rdma_aligned)
		iser_dma_unmap_task_data(iser_ctask);
		iser_dma_unmap_task_data(iser_task);
		}

		void iser_dto_buffs_release(struct iser_dto *dto)

drivers/infiniband/ulp/iser/iser_memory.c

+39 −38

File changed.

Preview size limit exceeded, changes collapsed.