The driver acquires the required SGLs from the pre-allocated pool.
Unified · Split
| @@ -247,6 +247,8 @@ struct mpi3mr_buf_map { · 246 unmodified lines | ||
| 247 | 247 | u32 kern_buf_len; |
| 248 | 248 | dma_addr_t kern_buf_dma; |
| 249 | 249 | u8 data_dir; |
| 250 | + u16 num_dma_desc; | |
| 251 | + struct dma_memory_desc *dma_desc; | |
| 250 | 252 | }; |
| 251 | 253 | |
| 252 | 254 | /* IOC State definitions */ |
| @@ -563,8 +563,37 @@ static long mpi3mr_bsg_process_drv_cmds(struct bsg_job *job) · 562 unmodified lines | ||
| 563 | 563 | return rval; |
| 564 | 564 | } |
| 565 | 565 | |
| 566 | +/** | |
| 567 | + * mpi3mr_total_num_ioctl_sges - Count number of SGEs required | |
| 568 | + * @drv_bufs: DMA address of the buffers to be placed in sgl | |
| 569 | + * @bufcnt: Number of DMA buffers | |
| 570 | + * | |
| 571 | + * This function returns total number of data SGEs required | |
| 572 | + * including zero length SGEs and excluding management request | |
| 573 | + * and response buffer for the given list of data buffer | |
| 574 | + * descriptors | |
| 575 | + * | |
| 576 | + * Return: Number of SGE elements needed | |
| 577 | + */ | |
| 578 | +static inline u16 mpi3mr_total_num_ioctl_sges(struct mpi3mr_buf_map *drv_bufs, | |
| 579 | + u8 bufcnt) | |
| 580 | +{ | |
| 581 | + u16 i, sge_count = 0; | |
| 582 | + | |
| 583 | + for (i = 0; i < bufcnt; i++, drv_bufs++) { | |
| 584 | + if (drv_bufs->data_dir == DMA_NONE || | |
| 585 | + drv_bufs->kern_buf) | |
| 586 | + continue; | |
| 587 | + sge_count += drv_bufs->num_dma_desc; | |
| 588 | + if (!drv_bufs->num_dma_desc) | |
| 589 | + sge_count++; | |
| 590 | + } | |
| 591 | + return sge_count; | |
| 592 | +} | |
| 593 | + | |
| 566 | 594 | /** |
| 567 | 595 | * mpi3mr_bsg_build_sgl - SGL construction for MPI commands |
| 596 | + * @mrioc: Adapter instance reference | |
| 568 | 597 | * @mpi_req: MPI request |
| 569 | 598 | * @sgl_offset: offset to start sgl in the MPI request |
| 570 | 599 | * @drv_bufs: DMA address of the buffers to be placed in sgl |
| @@ -576,27 +605,45 @@ static long mpi3mr_bsg_process_drv_cmds(struct bsg_job *job) · 5 unmodified lines | ||
| 576 | 605 | * This function places the DMA address of the given buffers in |
| 577 | 606 | * proper format as SGEs in the given MPI request. |
| 578 | 607 | * |
| 579 | − * Return: Nothing | |
| 608 | + * Return: 0 on success,-1 on failure | |
| 580 | 609 | */ |
| 581 | −static void mpi3mr_bsg_build_sgl(u8 *mpi_req, uint32_t sgl_offset, | |
| 582 | − struct mpi3mr_buf_map *drv_bufs, u8 bufcnt, u8 is_rmc, | |
| 583 | − u8 is_rmr, u8 num_datasges) | |
| 610 | +static int mpi3mr_bsg_build_sgl(struct mpi3mr_ioc *mrioc, u8 *mpi_req, | |
| 611 | + u32 sgl_offset, struct mpi3mr_buf_map *drv_bufs, | |
| 612 | + u8 bufcnt, u8 is_rmc, u8 is_rmr, u8 num_datasges) | |
| 584 | 613 | { |
| 614 | + struct mpi3_request_header *mpi_header = | |
| 615 | + (struct mpi3_request_header *)mpi_req; | |
| 585 | 616 | u8 *sgl = (mpi_req + sgl_offset), count = 0; |
| 586 | 617 | struct mpi3_mgmt_passthrough_request *rmgmt_req = |
| 587 | 618 | (struct mpi3_mgmt_passthrough_request *)mpi_req; |
| 588 | 619 | struct mpi3mr_buf_map *drv_buf_iter = drv_bufs; |
| 589 | − u8 sgl_flags, sgl_flags_last; | |
| 620 | + u8 flag, sgl_flags, sgl_flag_eob, sgl_flags_last, last_chain_sgl_flag; | |
| 621 | + u16 available_sges, i, sges_needed; | |
| 622 | + u32 sge_element_size = sizeof(struct mpi3_sge_common); | |
| 623 | + bool chain_used = false; | |
| 590 | 624 | |
| 591 | 625 | sgl_flags = MPI3_SGE_FLAGS_ELEMENT_TYPE_SIMPLE | |
| 592 | − MPI3_SGE_FLAGS_DLAS_SYSTEM | MPI3_SGE_FLAGS_END_OF_BUFFER; | |
| 593 | − sgl_flags_last = sgl_flags | MPI3_SGE_FLAGS_END_OF_LIST; | |
| 626 | + MPI3_SGE_FLAGS_DLAS_SYSTEM; | |
| 627 | + sgl_flag_eob = sgl_flags | MPI3_SGE_FLAGS_END_OF_BUFFER; | |
| 628 | + sgl_flags_last = sgl_flag_eob | MPI3_SGE_FLAGS_END_OF_LIST; | |
| 629 | + last_chain_sgl_flag = MPI3_SGE_FLAGS_ELEMENT_TYPE_LAST_CHAIN | | |
| 630 | + MPI3_SGE_FLAGS_DLAS_SYSTEM; | |
| 631 | + | |
| 632 | + sges_needed = mpi3mr_total_num_ioctl_sges(drv_bufs, bufcnt); | |
| 594 | 633 | |
| 595 | 634 | if (is_rmc) { |
| 596 | 635 | mpi3mr_add_sg_single(&rmgmt_req->command_sgl, |
| 597 | 636 | sgl_flags_last, drv_buf_iter->kern_buf_len, |
| 598 | 637 | drv_buf_iter->kern_buf_dma); |
| 599 | − sgl = (u8 *)drv_buf_iter->kern_buf + drv_buf_iter->bsg_buf_len; | |
| 638 | + sgl = (u8 *)drv_buf_iter->kern_buf + | |
| 639 | + drv_buf_iter->bsg_buf_len; | |
| 640 | + available_sges = (drv_buf_iter->kern_buf_len - | |
| 641 | + drv_buf_iter->bsg_buf_len) / sge_element_size; | |
| 642 | + | |
| 643 | + if (sges_needed > available_sges) | |
| 644 | + return -1; | |
| 645 | + | |
| 646 | + chain_used = true; | |
| 600 | 647 | drv_buf_iter++; |
| 601 | 648 | count++; |
| 602 | 649 | if (is_rmr) { |
| @@ -608,23 +655,95 @@ static void mpi3mr_bsg_build_sgl(u8 *mpi_req, uint32_t sgl_offset, · 5 unmodified lines | ||
| 608 | 655 | } else |
| 609 | 656 | mpi3mr_build_zero_len_sge( |
| 610 | 657 | &rmgmt_req->response_sgl); |
| 658 | + if (num_datasges) { | |
| 659 | + i = 0; | |
| 660 | + goto build_sges; | |
| 661 | + } | |
| 662 | + } else { | |
| 663 | + if (sgl_offset >= MPI3MR_ADMIN_REQ_FRAME_SZ) | |
| 664 | + return -1; | |
| 665 | + available_sges = (MPI3MR_ADMIN_REQ_FRAME_SZ - sgl_offset) / | |
| 666 | + sge_element_size; | |
| 667 | + if (!available_sges) | |
| 668 | + return -1; | |
| 611 | 669 | } |
| 612 | 670 | if (!num_datasges) { |
| 613 | 671 | mpi3mr_build_zero_len_sge(sgl); |
| 614 | − return; | |
| 672 | + return 0; | |
| 615 | 673 | } |
| 674 | + if (mpi_header->function == MPI3_BSG_FUNCTION_SMP_PASSTHROUGH) { | |
| 675 | + if ((sges_needed > 2) || (sges_needed > available_sges)) | |
| 676 | + return -1; | |
| 677 | + for (; count < bufcnt; count++, drv_buf_iter++) { | |
| 678 | + if (drv_buf_iter->data_dir == DMA_NONE || | |
| 679 | + !drv_buf_iter->num_dma_desc) | |
| 680 | + continue; | |
| 681 | + mpi3mr_add_sg_single(sgl, sgl_flags_last, | |
| 682 | + drv_buf_iter->dma_desc[0].size, | |
| 683 | + drv_buf_iter->dma_desc[0].dma_addr); | |
| 684 | + sgl += sge_element_size; | |
| 685 | + } | |
| 686 | + return 0; | |
| 687 | + } | |
| 688 | + i = 0; | |
| 689 | + | |
| 690 | +build_sges: | |
| 616 | 691 | for (; count < bufcnt; count++, drv_buf_iter++) { |
| 617 | 692 | if (drv_buf_iter->data_dir == DMA_NONE) |
| 618 | 693 | continue; |
| 619 | − if (num_datasges == 1 || !is_rmc) | |
| 620 | − mpi3mr_add_sg_single(sgl, sgl_flags_last, | |
| 621 | − drv_buf_iter->kern_buf_len, drv_buf_iter->kern_buf_dma); | |
| 622 | − else | |
| 623 | − mpi3mr_add_sg_single(sgl, sgl_flags, | |
| 624 | − drv_buf_iter->kern_buf_len, drv_buf_iter->kern_buf_dma); | |
| 625 | − sgl += sizeof(struct mpi3_sge_common); | |
| 694 | + if (!drv_buf_iter->num_dma_desc) { | |
| 695 | + if (chain_used && !available_sges) | |
| 696 | + return -1; | |
| 697 | + if (!chain_used && (available_sges == 1) && | |
| 698 | + (sges_needed > 1)) | |
| 699 | + goto setup_chain; | |
| 700 | + flag = sgl_flag_eob; | |
| 701 | + if (num_datasges == 1) | |
| 702 | + flag = sgl_flags_last; | |
| 703 | + mpi3mr_add_sg_single(sgl, flag, 0, 0); | |
| 704 | + sgl += sge_element_size; | |
| 705 | + sges_needed--; | |
| 706 | + available_sges--; | |
| 707 | + num_datasges--; | |
| 708 | + continue; | |
| 709 | + } | |
| 710 | + for (; i < drv_buf_iter->num_dma_desc; i++) { | |
| 711 | + if (chain_used && !available_sges) | |
| 712 | + return -1; | |
| 713 | + if (!chain_used && (available_sges == 1) && | |
| 714 | + (sges_needed > 1)) | |
| 715 | + goto setup_chain; | |
| 716 | + flag = sgl_flags; | |
| 717 | + if (i == (drv_buf_iter->num_dma_desc - 1)) { | |
| 718 | + if (num_datasges == 1) | |
| 719 | + flag = sgl_flags_last; | |
| 720 | + else | |
| 721 | + flag = sgl_flag_eob; | |
| 722 | + } | |
| 723 | + | |
| 724 | + mpi3mr_add_sg_single(sgl, flag, | |
| 725 | + drv_buf_iter->dma_desc[i].size, | |
| 726 | + drv_buf_iter->dma_desc[i].dma_addr); | |
| 727 | + sgl += sge_element_size; | |
| 728 | + available_sges--; | |
| 729 | + sges_needed--; | |
| 730 | + } | |
| 626 | 731 | num_datasges--; |
| 732 | + i = 0; | |
| 627 | 733 | } |
| 734 | + return 0; | |
| 735 | + | |
| 736 | +setup_chain: | |
| 737 | + available_sges = mrioc->ioctl_chain_sge.size / sge_element_size; | |
| 738 | + if (sges_needed > available_sges) | |
| 739 | + return -1; | |
| 740 | + mpi3mr_add_sg_single(sgl, last_chain_sgl_flag, | |
| 741 | + (sges_needed * sge_element_size), | |
| 742 | + mrioc->ioctl_chain_sge.dma_addr); | |
| 743 | + memset(mrioc->ioctl_chain_sge.addr, 0, mrioc->ioctl_chain_sge.size); | |
| 744 | + sgl = (u8 *)mrioc->ioctl_chain_sge.addr; | |
| 745 | + chain_used = true; | |
| 746 | + goto build_sges; | |
| 628 | 747 | } |
| 629 | 748 | |
| 630 | 749 | /** |
| @@ -935,10 +1054,66 @@ err_out: · 304 unmodified lines | ||
| 935 | 1054 | } |
| 936 | 1055 | return -1; |
| 937 | 1056 | } |
| 1057 | + | |
| 1058 | +/** | |
| 1059 | + * mpi3mr_map_data_buffer_dma - build dma descriptors for data | |
| 1060 | + * buffers | |
| 1061 | + * @mrioc: Adapter instance reference | |
| 1062 | + * @drv_buf: buffer map descriptor | |
| 1063 | + * @desc_count: Number of already consumed dma descriptors | |
| 1064 | + * | |
| 1065 | + * This function computes how many pre-allocated DMA descriptors | |
| 1066 | + * are required for the given data buffer and if those number of | |
| 1067 | + * descriptors are free, then setup the mapping of the scattered | |
| 1068 | + * DMA address to the given data buffer, if the data direction | |
| 1069 | + * of the buffer is DMA_TO_DEVICE then the actual data is copied to | |
| 1070 | + * the DMA buffers | |
| 1071 | + * | |
| 1072 | + * Return: 0 on success, -1 on failure | |
| 1073 | + */ | |
| 1074 | +static int mpi3mr_map_data_buffer_dma(struct mpi3mr_ioc *mrioc, | |
| 1075 | + struct mpi3mr_buf_map *drv_buf, | |
| 1076 | + u16 desc_count) | |
| 1077 | +{ | |
| 1078 | + u16 i, needed_desc = drv_buf->kern_buf_len / MPI3MR_IOCTL_SGE_SIZE; | |
| 1079 | + u32 buf_len = drv_buf->kern_buf_len, copied_len = 0; | |
| 1080 | + | |
| 1081 | + if (drv_buf->kern_buf_len % MPI3MR_IOCTL_SGE_SIZE) | |
| 1082 | + needed_desc++; | |
| 1083 | + if ((needed_desc + desc_count) > MPI3MR_NUM_IOCTL_SGE) { | |
| 1084 | + dprint_bsg_err(mrioc, "%s: DMA descriptor mapping error %d:%d:%d\n", | |
| 1085 | + __func__, needed_desc, desc_count, MPI3MR_NUM_IOCTL_SGE); | |
| 1086 | + return -1; | |
| 1087 | + } | |
| 1088 | + drv_buf->dma_desc = kzalloc(sizeof(*drv_buf->dma_desc) * needed_desc, | |
| 1089 | + GFP_KERNEL); | |
| 1090 | + if (!drv_buf->dma_desc) | |
| 1091 | + return -1; | |
| 1092 | + for (i = 0; i < needed_desc; i++, desc_count++) { | |
| 1093 | + drv_buf->dma_desc[i].addr = mrioc->ioctl_sge[desc_count].addr; | |
| 1094 | + drv_buf->dma_desc[i].dma_addr = | |
| 1095 | + mrioc->ioctl_sge[desc_count].dma_addr; | |
| 1096 | + if (buf_len < mrioc->ioctl_sge[desc_count].size) | |
| 1097 | + drv_buf->dma_desc[i].size = buf_len; | |
| 1098 | + else | |
| 1099 | + drv_buf->dma_desc[i].size = | |
| 1100 | + mrioc->ioctl_sge[desc_count].size; | |
| 1101 | + buf_len -= drv_buf->dma_desc[i].size; | |
| 1102 | + memset(drv_buf->dma_desc[i].addr, 0, | |
| 1103 | + mrioc->ioctl_sge[desc_count].size); | |
| 1104 | + if (drv_buf->data_dir == DMA_TO_DEVICE) { | |
| 1105 | + memcpy(drv_buf->dma_desc[i].addr, | |
| 1106 | + drv_buf->bsg_buf + copied_len, | |
| 1107 | + drv_buf->dma_desc[i].size); | |
| 1108 | + copied_len += drv_buf->dma_desc[i].size; | |
| 1109 | + } | |
| 1110 | + } | |
| 1111 | + drv_buf->num_dma_desc = needed_desc; | |
| 1112 | + return 0; | |
| 1113 | +} | |
| 938 | 1114 | /** |
| 939 | 1115 | * mpi3mr_bsg_process_mpt_cmds - MPI Pass through BSG handler |
| 940 | 1116 | * @job: BSG job reference |
| 941 | − * @reply_payload_rcv_len: length of payload recvd | |
| 942 | 1117 | * |
| 943 | 1118 | * This function is the top level handler for MPI Pass through |
| 944 | 1119 | * command, this does basic validation of the input data buffers, |
| @@ -954,10 +1129,9 @@ err_out: · 9 unmodified lines | ||
| 954 | 1129 | * Return: 0 on success and proper error codes on failure |
| 955 | 1130 | */ |
| 956 | 1131 | |
| 957 | −static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply_payload_rcv_len) | |
| 1132 | +static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job) | |
| 958 | 1133 | { |
| 959 | 1134 | long rval = -EINVAL; |
| 960 | − | |
| 961 | 1135 | struct mpi3mr_ioc *mrioc = NULL; |
| 962 | 1136 | u8 *mpi_req = NULL, *sense_buff_k = NULL; |
| 963 | 1137 | u8 mpi_msg_size = 0; |
| @@ -965,9 +1139,10 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 1 unmodified line | ||
| 965 | 1139 | struct mpi3mr_bsg_mptcmd *karg; |
| 966 | 1140 | struct mpi3mr_buf_entry *buf_entries = NULL; |
| 967 | 1141 | struct mpi3mr_buf_map *drv_bufs = NULL, *drv_buf_iter = NULL; |
| 968 | − u8 count, bufcnt = 0, is_rmcb = 0, is_rmrb = 0, din_cnt = 0, dout_cnt = 0; | |
| 969 | − u8 invalid_be = 0, erb_offset = 0xFF, mpirep_offset = 0xFF, sg_entries = 0; | |
| 970 | − u8 block_io = 0, resp_code = 0, nvme_fmt = 0; | |
| 1142 | + u8 count, bufcnt = 0, is_rmcb = 0, is_rmrb = 0; | |
| 1143 | + u8 din_cnt = 0, dout_cnt = 0; | |
| 1144 | + u8 invalid_be = 0, erb_offset = 0xFF, mpirep_offset = 0xFF; | |
| 1145 | + u8 block_io = 0, nvme_fmt = 0, resp_code = 0; | |
| 971 | 1146 | struct mpi3_request_header *mpi_header = NULL; |
| 972 | 1147 | struct mpi3_status_reply_descriptor *status_desc; |
| 973 | 1148 | struct mpi3_scsi_task_mgmt_request *tm_req; |
| @@ -979,6 +1154,7 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 5 unmodified lines | ||
| 979 | 1154 | u32 din_size = 0, dout_size = 0; |
| 980 | 1155 | u8 *din_buf = NULL, *dout_buf = NULL; |
| 981 | 1156 | u8 *sgl_iter = NULL, *sgl_din_iter = NULL, *sgl_dout_iter = NULL; |
| 1157 | + u16 rmc_size = 0, desc_count = 0; | |
| 982 | 1158 | |
| 983 | 1159 | bsg_req = job->request; |
| 984 | 1160 | karg = (struct mpi3mr_bsg_mptcmd *)&bsg_req->cmd.mptcmd; |
| @@ -987,6 +1163,12 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 2 unmodified lines | ||
| 987 | 1163 | if (!mrioc) |
| 988 | 1164 | return -ENODEV; |
| 989 | 1165 | |
| 1166 | + if (!mrioc->ioctl_sges_allocated) { | |
| 1167 | + dprint_bsg_err(mrioc, "%s: DMA memory was not allocated\n", | |
| 1168 | + __func__); | |
| 1169 | + return -ENOMEM; | |
| 1170 | + } | |
| 1171 | + | |
| 990 | 1172 | if (karg->timeout < MPI3MR_APP_DEFAULT_TIMEOUT) |
| 991 | 1173 | karg->timeout = MPI3MR_APP_DEFAULT_TIMEOUT; |
| 992 | 1174 | |
| @@ -1027,26 +1209,13 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 34 unmodified lines | ||
| 1027 | 1209 | |
| 1028 | 1210 | for (count = 0; count < bufcnt; count++, buf_entries++, drv_buf_iter++) { |
| 1029 | 1211 | |
| 1030 | − if (sgl_dout_iter > (dout_buf + job->request_payload.payload_len)) { | |
| 1031 | − dprint_bsg_err(mrioc, "%s: data_out buffer length mismatch\n", | |
| 1032 | − __func__); | |
| 1033 | − rval = -EINVAL; | |
| 1034 | − goto out; | |
| 1035 | − } | |
| 1036 | − if (sgl_din_iter > (din_buf + job->reply_payload.payload_len)) { | |
| 1037 | − dprint_bsg_err(mrioc, "%s: data_in buffer length mismatch\n", | |
| 1038 | − __func__); | |
| 1039 | − rval = -EINVAL; | |
| 1040 | − goto out; | |
| 1041 | − } | |
| 1042 | − | |
| 1043 | 1212 | switch (buf_entries->buf_type) { |
| 1044 | 1213 | case MPI3MR_BSG_BUFTYPE_RAIDMGMT_CMD: |
| 1045 | 1214 | sgl_iter = sgl_dout_iter; |
| 1046 | 1215 | sgl_dout_iter += buf_entries->buf_len; |
| 1047 | 1216 | drv_buf_iter->data_dir = DMA_TO_DEVICE; |
| 1048 | 1217 | is_rmcb = 1; |
| 1049 | − if (count != 0) | |
| 1218 | + if ((count != 0) || !buf_entries->buf_len) | |
| 1050 | 1219 | invalid_be = 1; |
| 1051 | 1220 | break; |
| 1052 | 1221 | case MPI3MR_BSG_BUFTYPE_RAIDMGMT_RESP: |
| @@ -1054,7 +1223,7 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 1 unmodified line | ||
| 1054 | 1223 | sgl_din_iter += buf_entries->buf_len; |
| 1055 | 1224 | drv_buf_iter->data_dir = DMA_FROM_DEVICE; |
| 1056 | 1225 | is_rmrb = 1; |
| 1057 | − if (count != 1 || !is_rmcb) | |
| 1226 | + if (count != 1 || !is_rmcb || !buf_entries->buf_len) | |
| 1058 | 1227 | invalid_be = 1; |
| 1059 | 1228 | break; |
| 1060 | 1229 | case MPI3MR_BSG_BUFTYPE_DATA_IN: |
| @@ -1062,7 +1231,7 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 1 unmodified line | ||
| 1062 | 1231 | sgl_din_iter += buf_entries->buf_len; |
| 1063 | 1232 | drv_buf_iter->data_dir = DMA_FROM_DEVICE; |
| 1064 | 1233 | din_cnt++; |
| 1065 | − din_size += drv_buf_iter->bsg_buf_len; | |
| 1234 | + din_size += buf_entries->buf_len; | |
| 1066 | 1235 | if ((din_cnt > 1) && !is_rmcb) |
| 1067 | 1236 | invalid_be = 1; |
| 1068 | 1237 | break; |
| @@ -1071,7 +1240,7 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 2 unmodified lines | ||
| 1071 | 1240 | sgl_dout_iter += buf_entries->buf_len; |
| 1072 | 1241 | drv_buf_iter->data_dir = DMA_TO_DEVICE; |
| 1073 | 1242 | dout_cnt++; |
| 1074 | − dout_size += drv_buf_iter->bsg_buf_len; | |
| 1243 | + dout_size += buf_entries->buf_len; | |
| 1075 | 1244 | if ((dout_cnt > 1) && !is_rmcb) |
| 1076 | 1245 | invalid_be = 1; |
| 1077 | 1246 | break; |
| @@ -1080,12 +1249,16 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 2 unmodified lines | ||
| 1080 | 1249 | sgl_din_iter += buf_entries->buf_len; |
| 1081 | 1250 | drv_buf_iter->data_dir = DMA_NONE; |
| 1082 | 1251 | mpirep_offset = count; |
| 1252 | + if (!buf_entries->buf_len) | |
| 1253 | + invalid_be = 1; | |
| 1083 | 1254 | break; |
| 1084 | 1255 | case MPI3MR_BSG_BUFTYPE_ERR_RESPONSE: |
| 1085 | 1256 | sgl_iter = sgl_din_iter; |
| 1086 | 1257 | sgl_din_iter += buf_entries->buf_len; |
| 1087 | 1258 | drv_buf_iter->data_dir = DMA_NONE; |
| 1088 | 1259 | erb_offset = count; |
| 1260 | + if (!buf_entries->buf_len) | |
| 1261 | + invalid_be = 1; | |
| 1089 | 1262 | break; |
| 1090 | 1263 | case MPI3MR_BSG_BUFTYPE_MPI_REQUEST: |
| 1091 | 1264 | sgl_iter = sgl_dout_iter; |
| @@ -1112,21 +1285,31 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 20 unmodified lines | ||
| 1112 | 1285 | goto out; |
| 1113 | 1286 | } |
| 1114 | 1287 | |
| 1115 | − drv_buf_iter->bsg_buf = sgl_iter; | |
| 1116 | − drv_buf_iter->bsg_buf_len = buf_entries->buf_len; | |
| 1117 | − | |
| 1118 | − } | |
| 1119 | − if (!is_rmcb && (dout_cnt || din_cnt)) { | |
| 1120 | − sg_entries = dout_cnt + din_cnt; | |
| 1121 | − if (((mpi_msg_size) + (sg_entries * | |
| 1122 | − sizeof(struct mpi3_sge_common))) > MPI3MR_ADMIN_REQ_FRAME_SZ) { | |
| 1123 | − dprint_bsg_err(mrioc, | |
| 1124 | − "%s:%d: invalid message size passed\n", | |
| 1125 | − __func__, __LINE__); | |
| 1288 | + if (sgl_dout_iter > (dout_buf + job->request_payload.payload_len)) { | |
| 1289 | + dprint_bsg_err(mrioc, "%s: data_out buffer length mismatch\n", | |
| 1290 | + __func__); | |
| 1126 | 1291 | rval = -EINVAL; |
| 1127 | 1292 | goto out; |
| 1128 | 1293 | } |
| 1294 | + if (sgl_din_iter > (din_buf + job->reply_payload.payload_len)) { | |
| 1295 | + dprint_bsg_err(mrioc, "%s: data_in buffer length mismatch\n", | |
| 1296 | + __func__); | |
| 1297 | + rval = -EINVAL; | |
| 1298 | + goto out; | |
| 1299 | + } | |
| 1300 | + | |
| 1301 | + drv_buf_iter->bsg_buf = sgl_iter; | |
| 1302 | + drv_buf_iter->bsg_buf_len = buf_entries->buf_len; | |
| 1129 | 1303 | } |
| 1304 | + | |
| 1305 | + if (is_rmcb && ((din_size + dout_size) > MPI3MR_MAX_APP_XFER_SIZE)) { | |
| 1306 | + dprint_bsg_err(mrioc, "%s:%d: invalid data transfer size passed for function 0x%x din_size = %d, dout_size = %d\n", | |
| 1307 | + __func__, __LINE__, mpi_header->function, din_size, | |
| 1308 | + dout_size); | |
| 1309 | + rval = -EINVAL; | |
| 1310 | + goto out; | |
| 1311 | + } | |
| 1312 | + | |
| 1130 | 1313 | if (din_size > MPI3MR_MAX_APP_XFER_SIZE) { |
| 1131 | 1314 | dprint_bsg_err(mrioc, |
| 1132 | 1315 | "%s:%d: invalid data transfer size passed for function 0x%x din_size=%d\n", |
| @@ -1142,30 +1325,64 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 9 unmodified lines | ||
| 1142 | 1325 | goto out; |
| 1143 | 1326 | } |
| 1144 | 1327 | |
| 1328 | + if (mpi_header->function == MPI3_BSG_FUNCTION_SMP_PASSTHROUGH) { | |
| 1329 | + if (din_size > MPI3MR_IOCTL_SGE_SIZE || | |
| 1330 | + dout_size > MPI3MR_IOCTL_SGE_SIZE) { | |
| 1331 | + dprint_bsg_err(mrioc, "%s:%d: invalid message size passed:%d:%d:%d:%d\n", | |
| 1332 | + __func__, __LINE__, din_cnt, dout_cnt, din_size, | |
| 1333 | + dout_size); | |
| 1334 | + rval = -EINVAL; | |
| 1335 | + goto out; | |
| 1336 | + } | |
| 1337 | + } | |
| 1338 | + | |
| 1145 | 1339 | drv_buf_iter = drv_bufs; |
| 1146 | 1340 | for (count = 0; count < bufcnt; count++, drv_buf_iter++) { |
| 1147 | 1341 | if (drv_buf_iter->data_dir == DMA_NONE) |
| 1148 | 1342 | continue; |
| 1149 | 1343 | |
| 1150 | 1344 | drv_buf_iter->kern_buf_len = drv_buf_iter->bsg_buf_len; |
| 1151 | − if (is_rmcb && !count) | |
| 1152 | − drv_buf_iter->kern_buf_len += ((dout_cnt + din_cnt) * | |
| 1153 | − sizeof(struct mpi3_sge_common)); | |
| 1154 | − | |
| 1155 | − if (!drv_buf_iter->kern_buf_len) | |
| 1156 | − continue; | |
| 1157 | − | |
| 1158 | − drv_buf_iter->kern_buf = dma_alloc_coherent(&mrioc->pdev->dev, | |
| 1159 | − drv_buf_iter->kern_buf_len, &drv_buf_iter->kern_buf_dma, | |
| 1160 | − GFP_KERNEL); | |
| 1161 | − if (!drv_buf_iter->kern_buf) { | |
| 1162 | − rval = -ENOMEM; | |
| 1163 | − goto out; | |
| 1164 | − } | |
| 1165 | − if (drv_buf_iter->data_dir == DMA_TO_DEVICE) { | |
| 1345 | + if (is_rmcb && !count) { | |
| 1346 | + drv_buf_iter->kern_buf_len = | |
| 1347 | + mrioc->ioctl_chain_sge.size; | |
| 1348 | + drv_buf_iter->kern_buf = | |
| 1349 | + mrioc->ioctl_chain_sge.addr; | |
| 1350 | + drv_buf_iter->kern_buf_dma = | |
| 1351 | + mrioc->ioctl_chain_sge.dma_addr; | |
| 1352 | + drv_buf_iter->dma_desc = NULL; | |
| 1353 | + drv_buf_iter->num_dma_desc = 0; | |
| 1354 | + memset(drv_buf_iter->kern_buf, 0, | |
| 1355 | + drv_buf_iter->kern_buf_len); | |
| 1166 | 1356 | tmplen = min(drv_buf_iter->kern_buf_len, |
| 1167 | − drv_buf_iter->bsg_buf_len); | |
| 1357 | + drv_buf_iter->bsg_buf_len); | |
| 1358 | + rmc_size = tmplen; | |
| 1168 | 1359 | memcpy(drv_buf_iter->kern_buf, drv_buf_iter->bsg_buf, tmplen); |
| 1360 | + } else if (is_rmrb && (count == 1)) { | |
| 1361 | + drv_buf_iter->kern_buf_len = | |
| 1362 | + mrioc->ioctl_resp_sge.size; | |
| 1363 | + drv_buf_iter->kern_buf = | |
| 1364 | + mrioc->ioctl_resp_sge.addr; | |
| 1365 | + drv_buf_iter->kern_buf_dma = | |
| 1366 | + mrioc->ioctl_resp_sge.dma_addr; | |
| 1367 | + drv_buf_iter->dma_desc = NULL; | |
| 1368 | + drv_buf_iter->num_dma_desc = 0; | |
| 1369 | + memset(drv_buf_iter->kern_buf, 0, | |
| 1370 | + drv_buf_iter->kern_buf_len); | |
| 1371 | + tmplen = min(drv_buf_iter->kern_buf_len, | |
| 1372 | + drv_buf_iter->bsg_buf_len); | |
| 1373 | + drv_buf_iter->kern_buf_len = tmplen; | |
| 1374 | + memset(drv_buf_iter->bsg_buf, 0, | |
| 1375 | + drv_buf_iter->bsg_buf_len); | |
| 1376 | + } else { | |
| 1377 | + if (!drv_buf_iter->kern_buf_len) | |
| 1378 | + continue; | |
| 1379 | + if (mpi3mr_map_data_buffer_dma(mrioc, drv_buf_iter, desc_count)) { | |
| 1380 | + rval = -ENOMEM; | |
| 1381 | + dprint_bsg_err(mrioc, "%s:%d: mapping data buffers failed\n", | |
| 1382 | + __func__, __LINE__); | |
| 1383 | + goto out; | |
| 1384 | + } | |
| 1385 | + desc_count += drv_buf_iter->num_dma_desc; | |
| 1169 | 1386 | } |
| 1170 | 1387 | } |
| 1171 | 1388 | |
| @@ -1235,9 +1452,14 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 63 unmodified lines | ||
| 1235 | 1452 | goto out; |
| 1236 | 1453 | } |
| 1237 | 1454 | } else { |
| 1238 | − mpi3mr_bsg_build_sgl(mpi_req, (mpi_msg_size), | |
| 1239 | − drv_bufs, bufcnt, is_rmcb, is_rmrb, | |
| 1240 | − (dout_cnt + din_cnt)); | |
| 1455 | + if (mpi3mr_bsg_build_sgl(mrioc, mpi_req, mpi_msg_size, | |
| 1456 | + drv_bufs, bufcnt, is_rmcb, is_rmrb, | |
| 1457 | + (dout_cnt + din_cnt))) { | |
| 1458 | + dprint_bsg_err(mrioc, "%s: sgl build failed\n", __func__); | |
| 1459 | + rval = -EAGAIN; | |
| 1460 | + mutex_unlock(&mrioc->bsg_cmds.mutex); | |
| 1461 | + goto out; | |
| 1462 | + } | |
| 1241 | 1463 | } |
| 1242 | 1464 | |
| 1243 | 1465 | if (mpi_header->function == MPI3_BSG_FUNCTION_SCSI_TASK_MGMT) { |
| @@ -1273,7 +1495,7 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 29 unmodified lines | ||
| 1273 | 1495 | if (mpi_header->function == MPI3_BSG_FUNCTION_MGMT_PASSTHROUGH) { |
| 1274 | 1496 | drv_buf_iter = &drv_bufs[0]; |
| 1275 | 1497 | dprint_dump(drv_buf_iter->kern_buf, |
| 1276 | − drv_buf_iter->kern_buf_len, "mpi3_mgmt_req"); | |
| 1498 | + rmc_size, "mpi3_mgmt_req"); | |
| 1277 | 1499 | } |
| 1278 | 1500 | } |
| 1279 | 1501 | |
| @@ -1308,10 +1530,9 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 28 unmodified lines | ||
| 1308 | 1530 | MPI3_BSG_FUNCTION_MGMT_PASSTHROUGH) { |
| 1309 | 1531 | drv_buf_iter = &drv_bufs[0]; |
| 1310 | 1532 | dprint_dump(drv_buf_iter->kern_buf, |
| 1311 | − drv_buf_iter->kern_buf_len, "mpi3_mgmt_req"); | |
| 1533 | + rmc_size, "mpi3_mgmt_req"); | |
| 1312 | 1534 | } |
| 1313 | 1535 | } |
| 1314 | − | |
| 1315 | 1536 | if ((mpi_header->function == MPI3_BSG_FUNCTION_NVME_ENCAPSULATED) || |
| 1316 | 1537 | (mpi_header->function == MPI3_BSG_FUNCTION_SCSI_IO)) |
| 1317 | 1538 | mpi3mr_issue_tm(mrioc, |
| @@ -1382,17 +1603,27 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 64 unmodified lines | ||
| 1382 | 1603 | for (count = 0; count < bufcnt; count++, drv_buf_iter++) { |
| 1383 | 1604 | if (drv_buf_iter->data_dir == DMA_NONE) |
| 1384 | 1605 | continue; |
| 1385 | − if (drv_buf_iter->data_dir == DMA_FROM_DEVICE) { | |
| 1386 | − tmplen = min(drv_buf_iter->kern_buf_len, | |
| 1387 | − drv_buf_iter->bsg_buf_len); | |
| 1606 | + if ((count == 1) && is_rmrb) { | |
| 1388 | 1607 | memcpy(drv_buf_iter->bsg_buf, |
| 1389 | − drv_buf_iter->kern_buf, tmplen); | |
| 1608 | + drv_buf_iter->kern_buf, | |
| 1609 | + drv_buf_iter->kern_buf_len); | |
| 1610 | + } else if (drv_buf_iter->data_dir == DMA_FROM_DEVICE) { | |
| 1611 | + tmplen = 0; | |
| 1612 | + for (desc_count = 0; | |
| 1613 | + desc_count < drv_buf_iter->num_dma_desc; | |
| 1614 | + desc_count++) { | |
| 1615 | + memcpy(((u8 *)drv_buf_iter->bsg_buf + tmplen), | |
| 1616 | + drv_buf_iter->dma_desc[desc_count].addr, | |
| 1617 | + drv_buf_iter->dma_desc[desc_count].size); | |
| 1618 | + tmplen += | |
| 1619 | + drv_buf_iter->dma_desc[desc_count].size; | |
| 1390 | 1620 | } |
| 1391 | 1621 | } |
| 1622 | + } | |
| 1392 | 1623 | |
| 1393 | 1624 | out_unlock: |
| 1394 | 1625 | if (din_buf) { |
| 1395 | − *reply_payload_rcv_len = | |
| 1626 | + job->reply_payload_rcv_len = | |
| 1396 | 1627 | sg_copy_from_buffer(job->reply_payload.sg_list, |
| 1397 | 1628 | job->reply_payload.sg_cnt, |
| 1398 | 1629 | din_buf, job->reply_payload.payload_len); |
| @@ -1408,13 +1639,8 @@ out: · 9 unmodified lines | ||
| 1408 | 1639 | kfree(mpi_req); |
| 1409 | 1640 | if (drv_bufs) { |
| 1410 | 1641 | drv_buf_iter = drv_bufs; |
| 1411 | − for (count = 0; count < bufcnt; count++, drv_buf_iter++) { | |
| 1412 | − if (drv_buf_iter->kern_buf && drv_buf_iter->kern_buf_dma) | |
| 1413 | − dma_free_coherent(&mrioc->pdev->dev, | |
| 1414 | − drv_buf_iter->kern_buf_len, | |
| 1415 | − drv_buf_iter->kern_buf, | |
| 1416 | − drv_buf_iter->kern_buf_dma); | |
| 1417 | − } | |
| 1642 | + for (count = 0; count < bufcnt; count++, drv_buf_iter++) | |
| 1643 | + kfree(drv_buf_iter->dma_desc); | |
| 1418 | 1644 | kfree(drv_bufs); |
| 1419 | 1645 | } |
| 1420 | 1646 | kfree(bsg_reply_buf); |
| @@ -1473,7 +1699,7 @@ static int mpi3mr_bsg_request(struct bsg_job *job) · 52 unmodified lines | ||
| 1473 | 1699 | rval = mpi3mr_bsg_process_drv_cmds(job); |
| 1474 | 1700 | break; |
| 1475 | 1701 | case MPI3MR_MPT_CMD: |
| 1476 | − rval = mpi3mr_bsg_process_mpt_cmds(job, &reply_payload_rcv_len); | |
| 1702 | + rval = mpi3mr_bsg_process_mpt_cmds(job); | |
| 1477 | 1703 | break; |
| 1478 | 1704 | default: |
| 1479 | 1705 | pr_err("%s: unsupported BSG command(0x%08x)\n", |