Lines Matching refs:req
804 } *req = NULL;
808 req = kzalloc(sizeof *req, GFP_KERNEL);
809 if (!req)
812 req->ib_param.flow_control = 1;
813 req->ib_param.retry_count = target->tl_retry_count;
819 req->ib_param.responder_resources = 4;
820 req->ib_param.rnr_retry_count = 7;
821 req->ib_param.max_cm_retries = 15;
823 req->ib_req.opcode = SRP_LOGIN_REQ;
824 req->ib_req.tag = 0;
825 req->ib_req.req_it_iu_len = cpu_to_be32(max_iu_len);
826 req->ib_req.req_buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT |
828 req->ib_req.req_flags = (multich ? SRP_MULTICHAN_MULTI :
831 req->ib_req.req_flags |= SRP_IMMED_REQUESTED;
832 req->ib_req.imm_data_offset = cpu_to_be16(SRP_IMM_DATA_OFFSET);
836 req->rdma_param.flow_control = req->ib_param.flow_control;
837 req->rdma_param.responder_resources =
838 req->ib_param.responder_resources;
839 req->rdma_param.initiator_depth = req->ib_param.initiator_depth;
840 req->rdma_param.retry_count = req->ib_param.retry_count;
841 req->rdma_param.rnr_retry_count = req->ib_param.rnr_retry_count;
842 req->rdma_param.private_data = &req->rdma_req;
843 req->rdma_param.private_data_len = sizeof(req->rdma_req);
845 req->rdma_req.opcode = req->ib_req.opcode;
846 req->rdma_req.tag = req->ib_req.tag;
847 req->rdma_req.req_it_iu_len = req->ib_req.req_it_iu_len;
848 req->rdma_req.req_buf_fmt = req->ib_req.req_buf_fmt;
849 req->rdma_req.req_flags = req->ib_req.req_flags;
850 req->rdma_req.imm_data_offset = req->ib_req.imm_data_offset;
852 ipi = req->rdma_req.initiator_port_id;
853 tpi = req->rdma_req.target_port_id;
859 req->ib_param.primary_path = &ch->ib_cm.path;
860 req->ib_param.alternate_path = NULL;
861 req->ib_param.service_id = target->ib_cm.service_id;
862 get_random_bytes(&req->ib_param.starting_psn, 4);
863 req->ib_param.starting_psn &= 0xffffff;
864 req->ib_param.qp_num = ch->qp->qp_num;
865 req->ib_param.qp_type = ch->qp->qp_type;
866 req->ib_param.local_cm_response_timeout = subnet_timeout + 2;
867 req->ib_param.remote_cm_response_timeout = subnet_timeout + 2;
868 req->ib_param.private_data = &req->ib_req;
869 req->ib_param.private_data_len = sizeof(req->ib_req);
871 ipi = req->ib_req.initiator_port_id;
872 tpi = req->ib_req.target_port_id;
911 status = rdma_connect(ch->rdma_cm.cm_id, &req->rdma_param);
913 status = ib_send_cm_req(ch->ib_cm.cm_id, &req->ib_param);
915 kfree(req);
968 struct srp_request *req = scsi_cmd_priv(cmd);
970 kfree(req->fr_list);
971 if (req->indirect_dma_addr) {
972 ib_dma_unmap_single(ibdev, req->indirect_dma_addr,
976 kfree(req->indirect_desc);
986 struct srp_request *req = scsi_cmd_priv(cmd);
991 req->fr_list = kmalloc_array(target->mr_per_cmd, sizeof(void *),
993 if (!req->fr_list)
996 req->indirect_desc = kmalloc(target->indirect_size, GFP_KERNEL);
997 if (!req->indirect_desc)
1000 dma_addr = ib_dma_map_single(ibdev, req->indirect_desc,
1008 req->indirect_dma_addr = dma_addr;
1160 static int srp_inv_rkey(struct srp_request *req, struct srp_rdma_ch *ch,
1171 wr.wr_cqe = &req->reg_cqe;
1172 req->reg_cqe.done = srp_inv_rkey_err_done;
1178 struct srp_request *req)
1193 for (i = req->nmdesc, pfr = req->fr_list; i > 0; i--, pfr++) {
1194 res = srp_inv_rkey(req, ch, (*pfr)->mr->rkey);
1203 if (req->nmdesc)
1204 srp_fr_pool_put(ch->fr_pool, req->fr_list,
1205 req->nmdesc);
1215 * @req: SRP request.
1217 * @scmnd: If NULL, take ownership of @req->scmnd. If not NULL, only take
1218 * ownership of @req->scmnd if it equals @scmnd.
1224 struct srp_request *req,
1231 if (req->scmnd &&
1232 (!sdev || req->scmnd->device == sdev) &&
1233 (!scmnd || req->scmnd == scmnd)) {
1234 scmnd = req->scmnd;
1235 req->scmnd = NULL;
1247 * @req: Request to be freed.
1248 * @scmnd: SCSI command associated with @req.
1251 static void srp_free_req(struct srp_rdma_ch *ch, struct srp_request *req,
1256 srp_unmap_data(scmnd, ch, req);
1263 static void srp_finish_req(struct srp_rdma_ch *ch, struct srp_request *req,
1266 struct scsi_cmnd *scmnd = srp_claim_req(ch, req, sdev, NULL);
1269 srp_free_req(ch, req, scmnd, 0);
1286 struct srp_request *req = scsi_cmd_priv(scmnd);
1288 srp_finish_req(ch, req, NULL, context->scsi_result);
1421 struct srp_request *req,
1464 dev_name(&req->scmnd->device->sdev_gendev), sg_nents,
1471 req->reg_cqe.done = srp_reg_mr_err_done;
1475 wr.wr.wr_cqe = &req->reg_cqe;
1500 struct srp_request *req, struct scatterlist *scat,
1505 state->fr.next = req->fr_list;
1506 state->fr.end = req->fr_list + ch->target->mr_per_cmd;
1515 n = srp_map_finish_fr(state, req, ch, count, &sg_offset);
1528 struct srp_request *req, struct scatterlist *scat,
1550 static int srp_map_idb(struct srp_rdma_ch *ch, struct srp_request *req,
1566 state.base_dma_addr = req->indirect_dma_addr;
1571 sg_init_one(idb_sg, req->indirect_desc, idb_len);
1572 idb_sg->dma_address = req->indirect_dma_addr; /* hack! */
1576 ret = srp_map_finish_fr(&state, req, ch, 1, NULL);
1590 struct srp_rdma_ch *ch, struct srp_request *req,
1599 desc_len += be32_to_cpu(req->indirect_desc[i].len);
1601 for (i = 0, pfr = req->fr_list; i < state->nmdesc; i++, pfr++)
1603 if (desc_len != scsi_bufflen(req->scmnd) ||
1604 mr_len > scsi_bufflen(req->scmnd))
1606 scsi_bufflen(req->scmnd), desc_len, mr_len,
1614 * @req: SRP request
1621 struct srp_request *req)
1625 struct srp_cmd *cmd = req->cmd->buf;
1636 req->cmd->num_sge = 1;
1665 struct ib_sge *sge = &req->cmd->sge[1];
1669 req->nmdesc = 0;
1678 req->cmd->num_sge += count;
1700 req->nmdesc = 0;
1710 ib_dma_sync_single_for_cpu(ibdev, req->indirect_dma_addr,
1714 state.desc = req->indirect_desc;
1716 ret = srp_map_sg_fr(&state, ch, req, scat, count);
1718 ret = srp_map_sg_dma(&state, ch, req, scat, count);
1719 req->nmdesc = state.nmdesc;
1727 srp_check_mapping(&state, ch, req, scat, count);
1744 *buf = req->indirect_desc[0];
1765 memcpy(indirect_hdr->desc_list, req->indirect_desc,
1769 ret = srp_map_idb(ch, req, state.gen.next, state.gen.end,
1773 req->nmdesc++;
1778 indirect_hdr->table_desc.va = cpu_to_be64(req->indirect_dma_addr);
1788 ib_dma_sync_single_for_device(ibdev, req->indirect_dma_addr, table_len,
1800 srp_unmap_data(scmnd, ch, req);
1801 if (ret == -ENOMEM && req->nmdesc >= target->mr_pool_size)
1936 struct srp_request *req;
1957 req = scsi_cmd_priv(scmnd);
1958 scmnd = srp_claim_req(ch, req, NULL, scmnd);
1985 srp_free_req(ch, req, scmnd,
2028 struct srp_cred_req *req)
2032 .tag = req->tag,
2034 s32 delta = be32_to_cpu(req->req_lim_delta);
2042 struct srp_aer_req *req)
2047 .tag = req->tag,
2049 s32 delta = be32_to_cpu(req->req_lim_delta);
2052 "ignoring AER for LUN %llu\n", scsilun_to_int(&req->lun));
2156 struct srp_request *req = scsi_cmd_priv(scmnd);
2197 req->scmnd = scmnd;
2198 req->cmd = iu;
2200 len = srp_map_data(scmnd, ch, req);
2227 srp_unmap_data(scmnd, ch, req);
2236 req->scmnd = NULL;
2783 struct srp_request *req = scsi_cmd_priv(scmnd);
2795 if (!srp_claim_req(ch, req, NULL, scmnd))
2801 srp_free_req(ch, req, scmnd, 0);