int iser_send_control(struct iscsi_conn *conn, struct iscsi_mgmt_task *mtask) { struct iscsi_iser_conn *iser_conn = conn->dd_data; struct iser_desc *mdesc = mtask->dd_data; struct iser_dto *send_dto = NULL; unsigned long data_seg_len; int err = 0; struct iser_regd_buf *regd_buf; struct iser_device *device; 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,mtask)) 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; 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(mtask->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 = mtask->data; regd_buf->data_size = mtask->data_count; iser_reg_single(device, regd_buf, DMA_TO_DEVICE); iser_dto_add_regd_buff(send_dto, regd_buf, 0, data_seg_len); } if (iser_post_receive_control(conn) != 0) { iser_err("post_rcv_buff failed!\n"); err = -ENOMEM; goto send_control_error; } err = iser_post_send(mdesc); if (!err) return 0; send_control_error: iser_dto_buffs_release(send_dto); iser_err("conn %p failed err %d\n",conn, err); return err; }
/** * iser_send_data_out - send data out PDU */ int iser_send_data_out(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask, struct iscsi_data *hdr) { struct iscsi_iser_conn *iser_conn = conn->dd_data; struct iscsi_iser_cmd_task *iser_ctask = ctask->dd_data; struct iser_desc *tx_desc = NULL; struct iser_dto *send_dto = NULL; unsigned long buf_offset; unsigned long data_seg_len; unsigned int itt; int err = 0; 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)) return -ENOBUFS; itt = ntohl(hdr->itt); data_seg_len = ntoh24(hdr->dlength); buf_offset = ntohl(hdr->offset); iser_dbg("%s itt %d dseg_len %d offset %d\n", __func__,(int)itt,(int)data_seg_len,(int)buf_offset); tx_desc = kmem_cache_alloc(ig.desc_cache, GFP_NOIO); if (tx_desc == NULL) { iser_err("Failed to alloc desc for post dataout\n"); return -ENOMEM; } tx_desc->type = ISCSI_TX_DATAOUT; memcpy(&tx_desc->iscsi_header, hdr, sizeof(struct iscsi_hdr)); /* build the tx desc regd header and add it to the tx desc dto */ send_dto = &tx_desc->dto; send_dto->ctask = iser_ctask; iser_create_send_desc(iser_conn, tx_desc); iser_reg_single(iser_conn->ib_conn->device, send_dto->regd[0], DMA_TO_DEVICE); /* 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], buf_offset, data_seg_len); if (buf_offset + data_seg_len > iser_ctask->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); err = -EINVAL; goto send_data_out_error; } iser_dbg("data-out itt: %d, offset: %ld, sz: %ld\n", itt, buf_offset, data_seg_len); err = iser_post_send(tx_desc); if (!err) return 0; send_data_out_error: iser_dto_buffs_release(send_dto); kmem_cache_free(ig.desc_cache, tx_desc); iser_err("conn %p failed err %d\n",conn, err); return err; }
/** * iser_send_command - send command PDU */ int iser_send_command(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask) { struct iscsi_iser_conn *iser_conn = conn->dd_data; struct iscsi_iser_cmd_task *iser_ctask = ctask->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; 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)) 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); if (hdr->flags & ISCSI_FLAG_CMD_READ) data_buf = &iser_ctask->data[ISER_DIR_IN]; else data_buf = &iser_ctask->data[ISER_DIR_OUT]; if (sc->use_sg) { /* using a scatter list */ data_buf->buf = sc->request_buffer; data_buf->size = sc->use_sg; } else if (sc->request_bufflen) { /* using a single buffer - convert it into one entry SG */ sg_init_one(&data_buf->sg_single, sc->request_buffer, sc->request_bufflen); data_buf->buf = &data_buf->sg_single; data_buf->size = 1; } data_buf->data_len = sc->request_bufflen; if (hdr->flags & ISCSI_FLAG_CMD_READ) { err = iser_prepare_read_cmd(ctask, 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, edtl); if (err) goto send_command_error; } iser_reg_single(iser_conn->ib_conn->device, send_dto->regd[0], DMA_TO_DEVICE); if (iser_post_receive_control(conn) != 0) { iser_err("post_recv failed!\n"); err = -ENOMEM; goto send_command_error; } iser_ctask->status = ISER_TASK_STATUS_STARTED; err = iser_post_send(&iser_ctask->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); return err; }
/** * iser_post_receive_control - allocates, initializes and posts receive DTO. */ static int iser_post_receive_control(struct iscsi_conn *conn) { struct iscsi_iser_conn *iser_conn = conn->dd_data; struct iser_desc *rx_desc; struct iser_regd_buf *regd_hdr; struct iser_regd_buf *regd_data; struct iser_dto *recv_dto = NULL; struct iser_device *device = iser_conn->ib_conn->device; int rx_data_size, err = 0; rx_desc = kmem_cache_alloc(ig.desc_cache, GFP_NOIO); if (rx_desc == NULL) { iser_err("Failed to alloc desc for post recv\n"); return -ENOMEM; } rx_desc->type = ISCSI_RX; /* for the login sequence we must support rx of upto 8K; login is done * after conn create/bind (connect) and conn stop/bind (reconnect), * what's common for both schemes is that the connection is not started */ if (conn->c_stage != ISCSI_CONN_STARTED) rx_data_size = DEFAULT_MAX_RECV_DATA_SEGMENT_LENGTH; else /* FIXME till user space sets conn->max_recv_dlength correctly */ rx_data_size = 128; rx_desc->data = kmalloc(rx_data_size, GFP_NOIO); if (rx_desc->data == NULL) { iser_err("Failed to alloc data buf for post recv\n"); err = -ENOMEM; goto post_rx_kmalloc_failure; } recv_dto = &rx_desc->dto; recv_dto->ib_conn = iser_conn->ib_conn; recv_dto->regd_vector_len = 0; regd_hdr = &rx_desc->hdr_regd_buf; memset(regd_hdr, 0, sizeof(struct iser_regd_buf)); regd_hdr->device = device; regd_hdr->virt_addr = rx_desc; /* == &rx_desc->iser_header */ regd_hdr->data_size = ISER_TOTAL_HEADERS_LEN; iser_reg_single(device, regd_hdr, DMA_FROM_DEVICE); iser_dto_add_regd_buff(recv_dto, regd_hdr, 0, 0); regd_data = &rx_desc->data_regd_buf; memset(regd_data, 0, sizeof(struct iser_regd_buf)); regd_data->device = device; regd_data->virt_addr = rx_desc->data; regd_data->data_size = rx_data_size; iser_reg_single(device, regd_data, DMA_FROM_DEVICE); iser_dto_add_regd_buff(recv_dto, regd_data, 0, 0); err = iser_post_recv(rx_desc); if (!err) return 0; /* iser_post_recv failed */ iser_dto_buffs_release(recv_dto); kfree(rx_desc->data); post_rx_kmalloc_failure: kmem_cache_free(ig.desc_cache, rx_desc); return err; }
int iser_send_control(struct iscsi_conn *conn, struct iscsi_task *task) { struct iscsi_iser_conn *iser_conn = conn->dd_data; 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; struct iser_regd_buf *regd_buf; struct iser_device *device; unsigned char opcode; 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, 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->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(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 = 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, 0, data_seg_len); } opcode = task->hdr->opcode & ISCSI_OPCODE_MASK; /* post recv buffer for response if one is expected */ if (!(opcode == ISCSI_OP_NOOP_OUT && task->hdr->itt == RESERVED_ITT)) { if (iser_post_receive_control(conn) != 0) { iser_err("post_rcv_buff failed!\n"); err = -ENOMEM; goto send_control_error; } } err = iser_post_send(mdesc); if (!err) return 0; send_control_error: iser_dto_buffs_release(send_dto); iser_err("conn %p failed err %d\n",conn, err); return err; }
/** * iser_post_receive_control - allocates, initializes and posts receive DTO. */ static int iser_post_receive_control(struct iscsi_conn *conn) { struct iscsi_iser_conn *iser_conn = conn->dd_data; struct iser_desc *rx_desc; struct iser_regd_buf *regd_hdr; struct iser_regd_buf *regd_data; struct iser_dto *recv_dto = NULL; struct iser_device *device = iser_conn->ib_conn->device; int rx_data_size, err; int posts, outstanding_unexp_pdus; /* for the login sequence we must support rx of upto 8K; login is done * after conn create/bind (connect) and conn stop/bind (reconnect), * what's common for both schemes is that the connection is not started */ if (conn->c_stage != ISCSI_CONN_STARTED) rx_data_size = ISCSI_DEF_MAX_RECV_SEG_LEN; else /* FIXME till user space sets conn->max_recv_dlength correctly */ rx_data_size = 128; outstanding_unexp_pdus = atomic_xchg(&iser_conn->ib_conn->unexpected_pdu_count, 0); /* * in addition to the response buffer, replace those consumed by * unexpected pdus. */ for (posts = 0; posts < 1 + outstanding_unexp_pdus; posts++) { rx_desc = kmem_cache_alloc(ig.desc_cache, GFP_NOIO); if (rx_desc == NULL) { iser_err("Failed to alloc desc for post recv %d\n", posts); err = -ENOMEM; goto post_rx_cache_alloc_failure; } rx_desc->type = ISCSI_RX; rx_desc->data = kmalloc(rx_data_size, GFP_NOIO); if (rx_desc->data == NULL) { iser_err("Failed to alloc data buf for post recv %d\n", posts); err = -ENOMEM; goto post_rx_kmalloc_failure; } recv_dto = &rx_desc->dto; recv_dto->ib_conn = iser_conn->ib_conn; recv_dto->regd_vector_len = 0; regd_hdr = &rx_desc->hdr_regd_buf; memset(regd_hdr, 0, sizeof(struct iser_regd_buf)); regd_hdr->device = device; regd_hdr->virt_addr = rx_desc; /* == &rx_desc->iser_header */ regd_hdr->data_size = ISER_TOTAL_HEADERS_LEN; iser_reg_single(device, regd_hdr, DMA_FROM_DEVICE); iser_dto_add_regd_buff(recv_dto, regd_hdr, 0, 0); regd_data = &rx_desc->data_regd_buf; memset(regd_data, 0, sizeof(struct iser_regd_buf)); regd_data->device = device; regd_data->virt_addr = rx_desc->data; regd_data->data_size = rx_data_size; iser_reg_single(device, regd_data, DMA_FROM_DEVICE); iser_dto_add_regd_buff(recv_dto, regd_data, 0, 0); err = iser_post_recv(rx_desc); if (err) { iser_err("Failed iser_post_recv for post %d\n", posts); goto post_rx_post_recv_failure; } } /* all posts successful */ return 0; post_rx_post_recv_failure: iser_dto_buffs_release(recv_dto); kfree(rx_desc->data); post_rx_kmalloc_failure: kmem_cache_free(ig.desc_cache, rx_desc); post_rx_cache_alloc_failure: if (posts > 0) { /* * response buffer posted, but did not replace all unexpected * pdu recv bufs. Ignore error, retry occurs next send */ outstanding_unexp_pdus -= (posts - 1); err = 0; } atomic_add(outstanding_unexp_pdus, &iser_conn->ib_conn->unexpected_pdu_count); return err; }