Lines Matching refs:cmd
340 struct ib_uverbs_get_context cmd;
351 if (copy_from_user(&cmd, buf, sizeof cmd))
361 INIT_UDATA(&udata, buf + sizeof cmd,
362 (unsigned long) cmd.response + sizeof resp,
363 in_len - sizeof cmd, out_len - sizeof resp);
407 if (copy_to_user((void __user *) (unsigned long) cmd.response,
489 struct ib_uverbs_query_device cmd;
497 if (copy_from_user(&cmd, buf, sizeof cmd))
506 if (copy_to_user((void __user *)(unsigned long) cmd.response,
517 struct ib_uverbs_query_port cmd;
525 if (copy_from_user(&cmd, buf, sizeof cmd))
528 ret = ib_query_port(file->device->ib_dev, cmd.port_num, &attr);
554 cmd.port_num);
556 if (copy_to_user((void __user *) (unsigned long) cmd.response,
567 struct ib_uverbs_alloc_pd cmd;
577 if (copy_from_user(&cmd, buf, sizeof cmd))
580 INIT_UDATA(&udata, buf + sizeof cmd,
581 (unsigned long) cmd.response + sizeof resp,
582 in_len - sizeof cmd, out_len - sizeof resp);
610 if (copy_to_user((void __user *) (unsigned long) cmd.response,
641 struct ib_uverbs_dealloc_pd cmd;
645 if (copy_from_user(&cmd, buf, sizeof cmd))
648 uobj = idr_write_uobj(&ib_uverbs_pd_idr, cmd.pd_handle, file->ucontext);
761 struct ib_uverbs_open_xrcd cmd;
774 if (copy_from_user(&cmd, buf, sizeof cmd))
777 INIT_UDATA(&udata, buf + sizeof cmd,
778 (unsigned long) cmd.response + sizeof resp,
779 in_len - sizeof cmd, out_len - sizeof resp);
783 if (cmd.fd != -1) {
785 f = fdget(cmd.fd);
793 if (!xrcd && !(cmd.oflags & O_CREAT)) {
799 if (xrcd && cmd.oflags & O_EXCL) {
850 if (copy_to_user((void __user *) (unsigned long) cmd.response,
898 struct ib_uverbs_close_xrcd cmd;
906 if (copy_from_user(&cmd, buf, sizeof cmd))
910 uobj = idr_write_uobj(&ib_uverbs_xrcd_idr, cmd.xrcd_handle, file->ucontext);
975 struct ib_uverbs_reg_mr cmd;
986 if (copy_from_user(&cmd, buf, sizeof cmd))
989 INIT_UDATA(&udata, buf + sizeof cmd,
990 (unsigned long) cmd.response + sizeof resp,
991 in_len - sizeof cmd, out_len - sizeof resp);
993 if ((cmd.start & ~PAGE_MASK) != (cmd.hca_va & ~PAGE_MASK))
996 ret = ib_check_mr_access(cmd.access_flags);
1007 pd = idr_read_pd(cmd.pd_handle, file->ucontext);
1019 mr = pd->device->reg_user_mr(pd, cmd.start, cmd.length, cmd.hca_va,
1020 cmd.access_flags, &udata, uobj->id);
1039 if (copy_to_user((void __user *) (unsigned long) cmd.response,
1075 struct ib_uverbs_dereg_mr cmd;
1080 if (copy_from_user(&cmd, buf, sizeof cmd))
1083 uobj = idr_write_uobj(&ib_uverbs_mr_idr, cmd.mr_handle, file->ucontext);
1113 struct ib_uverbs_alloc_mw cmd;
1123 if (copy_from_user(&cmd, buf, sizeof(cmd)))
1133 pd = idr_read_pd(cmd.pd_handle, file->ucontext);
1139 mw = pd->device->alloc_mw(pd, cmd.mw_type);
1159 if (copy_to_user((void __user *)(unsigned long)cmd.response,
1195 struct ib_uverbs_dealloc_mw cmd;
1200 if (copy_from_user(&cmd, buf, sizeof(cmd)))
1203 uobj = idr_write_uobj(&ib_uverbs_mw_idr, cmd.mw_handle, file->ucontext);
1233 struct ib_uverbs_create_comp_channel cmd;
1241 if (copy_from_user(&cmd, buf, sizeof cmd))
1255 if (copy_to_user((void __user *) (unsigned long) cmd.response,
1271 struct ib_uverbs_create_cq *cmd;
1285 cmd = vcmd;
1287 cmd_sz = ex ? sizeof(*cmd_e) : sizeof(*cmd);
1289 in_len - sizeof(cmd), out_len - sizeof(resp));
1291 if (cmd->comp_vector >= file->device->num_comp_vectors)
1298 init_uobj(&obj->uobject, cmd->user_handle, file->ucontext,
1302 if (cmd->comp_channel >= 0) {
1303 ev_file = ib_uverbs_lookup_comp_file(cmd->comp_channel);
1317 attr.cqe = cmd->cqe;
1318 attr.comp_vector = cmd->comp_vector;
1378 struct ib_uverbs_create_cq cmd;
1380 if (copy_from_user(&cmd, buf, sizeof(cmd)))
1383 return create_cq(file, buf, in_len, out_len, &cmd,
1385 (void __user *) (unsigned long) cmd.response);
1392 struct ib_uverbs_resize_cq cmd;
1398 if (copy_from_user(&cmd, buf, sizeof cmd))
1401 INIT_UDATA(&udata, buf + sizeof cmd,
1402 (unsigned long) cmd.response + sizeof resp,
1403 in_len - sizeof cmd, out_len - sizeof resp);
1405 cq = idr_read_cq(cmd.cq_handle, file->ucontext, 0);
1409 ret = cq->device->resize_cq(cq, cmd.cqe, &udata);
1415 if (copy_to_user((void __user *) (unsigned long) cmd.response,
1455 struct ib_uverbs_poll_cq cmd;
1463 if (copy_from_user(&cmd, buf, sizeof cmd))
1466 cq = idr_read_cq(cmd.cq_handle, file->ucontext, 0);
1471 header_ptr = (void __user *)(unsigned long) cmd.response;
1475 while (resp.count < cmd.ne) {
1506 struct ib_uverbs_req_notify_cq cmd;
1509 if (copy_from_user(&cmd, buf, sizeof cmd))
1512 cq = idr_read_cq(cmd.cq_handle, file->ucontext, 0);
1516 ib_req_notify_cq(cq, cmd.solicited_only ?
1528 struct ib_uverbs_destroy_cq cmd;
1536 if (copy_from_user(&cmd, buf, sizeof cmd))
1539 uobj = idr_write_uobj(&ib_uverbs_cq_idr, cmd.cq_handle, file->ucontext);
1569 if (copy_to_user((void __user *) (unsigned long) cmd.response,
1595 struct ib_uverbs_create_qp *cmd;
1604 cmd = &cmd_obj.basic;
1615 response = (void __user *) (unsigned long) cmd->response;
1618 cmd->qp_type == IB_QPT_RAW_PACKET && priv_check(curthread, PRIV_NET_RAW))
1628 init_uobj(&obj->uevent.uobject, cmd->user_handle, file->ucontext, &qp_lock_class);
1631 if (cmd->qp_type == IB_QPT_XRC_TGT) {
1632 xrcd = idr_read_xrcd(cmd->pd_handle, file->ucontext, &xrcd_uobj);
1639 if (cmd->qp_type == IB_QPT_XRC_INI) {
1640 cmd->max_recv_wr = 0;
1641 cmd->max_recv_sge = 0;
1643 if (cmd->is_srq) {
1644 srq = idr_read_srq(cmd->srq_handle, file->ucontext);
1651 if (cmd->recv_cq_handle != cmd->send_cq_handle) {
1652 rcq = idr_read_cq(cmd->recv_cq_handle, file->ucontext, 0);
1660 scq = idr_read_cq(cmd->send_cq_handle, file->ucontext, !!rcq);
1662 pd = idr_read_pd(cmd->pd_handle, file->ucontext);
1678 attr.sq_sig_type = cmd->sq_sig_all ? IB_SIGNAL_ALL_WR : IB_SIGNAL_REQ_WR;
1679 attr.qp_type = cmd->qp_type;
1682 attr.cap.max_send_wr = cmd->max_send_wr;
1683 attr.cap.max_recv_wr = cmd->max_recv_wr;
1684 attr.cap.max_send_sge = cmd->max_send_sge;
1685 attr.cap.max_recv_sge = cmd->max_recv_sge;
1686 attr.cap.max_inline_data = cmd->max_inline_data;
1692 if (cmd->qp_type == IB_QPT_XRC_TGT)
1702 if (cmd->qp_type != IB_QPT_XRC_TGT) {
1791 struct ib_uverbs_open_qp cmd;
1804 if (copy_from_user(&cmd, buf, sizeof cmd))
1807 INIT_UDATA(&udata, buf + sizeof cmd,
1808 (unsigned long) cmd.response + sizeof resp,
1809 in_len - sizeof cmd, out_len - sizeof resp);
1815 init_uobj(&obj->uevent.uobject, cmd.user_handle, file->ucontext, &qp_lock_class);
1818 xrcd = idr_read_xrcd(cmd.pd_handle, file->ucontext, &xrcd_uobj);
1826 attr.qp_num = cmd.qpn;
1827 attr.qp_type = cmd.qp_type;
1850 if (copy_to_user((void __user *) (unsigned long) cmd.response,
1885 struct ib_uverbs_query_qp cmd;
1892 if (copy_from_user(&cmd, buf, sizeof cmd))
1902 qp = idr_read_qp(cmd.qp_handle, file->ucontext);
1908 ret = ib_query_qp(qp, attr, cmd.attr_mask, init_attr);
1970 if (copy_to_user((void __user *) (unsigned long) cmd.response,
2000 struct ib_uverbs_modify_qp_ex cmd;
2012 p = &cmd;
2013 p += sizeof(cmd.comp_mask);
2018 if (copy_from_user(&cmd, buf, sizeof(cmd)))
2022 INIT_UDATA(&udata, buf + sizeof cmd, NULL, in_len - sizeof cmd,
2030 qp = idr_read_qp(cmd.qp_handle, file->ucontext);
2036 attr->qp_state = cmd.qp_state;
2037 attr->cur_qp_state = cmd.cur_qp_state;
2038 attr->path_mtu = cmd.path_mtu;
2039 attr->path_mig_state = cmd.path_mig_state;
2040 attr->qkey = cmd.qkey;
2041 attr->rq_psn = cmd.rq_psn;
2042 attr->sq_psn = cmd.sq_psn;
2043 attr->dest_qp_num = cmd.dest_qp_num;
2044 attr->qp_access_flags = cmd.qp_access_flags;
2045 attr->pkey_index = cmd.pkey_index;
2046 attr->alt_pkey_index = cmd.alt_pkey_index;
2047 attr->en_sqd_async_notify = cmd.en_sqd_async_notify;
2048 attr->max_rd_atomic = cmd.max_rd_atomic;
2049 attr->max_dest_rd_atomic = cmd.max_dest_rd_atomic;
2050 attr->min_rnr_timer = cmd.min_rnr_timer;
2051 attr->port_num = cmd.port_num;
2052 attr->timeout = cmd.timeout;
2053 attr->retry_cnt = cmd.retry_cnt;
2054 attr->rnr_retry = cmd.rnr_retry;
2055 attr->alt_port_num = cmd.alt_port_num;
2056 attr->alt_timeout = cmd.alt_timeout;
2058 memcpy(attr->ah_attr.grh.dgid.raw, cmd.dest.dgid, 16);
2059 attr->ah_attr.grh.flow_label = cmd.dest.flow_label;
2060 attr->ah_attr.grh.sgid_index = cmd.dest.sgid_index;
2061 attr->ah_attr.grh.hop_limit = cmd.dest.hop_limit;
2062 attr->ah_attr.grh.traffic_class = cmd.dest.traffic_class;
2063 attr->ah_attr.dlid = cmd.dest.dlid;
2064 attr->ah_attr.sl = cmd.dest.sl;
2065 attr->ah_attr.src_path_bits = cmd.dest.src_path_bits;
2066 attr->ah_attr.static_rate = cmd.dest.static_rate;
2067 attr->ah_attr.ah_flags = cmd.dest.is_global ? IB_AH_GRH : 0;
2068 attr->ah_attr.port_num = cmd.dest.port_num;
2070 memcpy(attr->alt_ah_attr.grh.dgid.raw, cmd.alt_dest.dgid, 16);
2071 attr->alt_ah_attr.grh.flow_label = cmd.alt_dest.flow_label;
2072 attr->alt_ah_attr.grh.sgid_index = cmd.alt_dest.sgid_index;
2073 attr->alt_ah_attr.grh.hop_limit = cmd.alt_dest.hop_limit;
2074 attr->alt_ah_attr.grh.traffic_class = cmd.alt_dest.traffic_class;
2075 attr->alt_ah_attr.dlid = cmd.alt_dest.dlid;
2076 attr->alt_ah_attr.sl = cmd.alt_dest.sl;
2077 attr->alt_ah_attr.src_path_bits = cmd.alt_dest.src_path_bits;
2078 attr->alt_ah_attr.static_rate = cmd.alt_dest.static_rate;
2079 attr->alt_ah_attr.ah_flags = cmd.alt_dest.is_global ? IB_AH_GRH : 0;
2080 attr->alt_ah_attr.port_num = cmd.alt_dest.port_num;
2081 port_num = (cmd.attr_mask & IB_QP_PORT) ? cmd.port_num : qp->port_num;
2082 if ((cmd.attr_mask & IB_QP_AV) && port_num &&
2107 cmd.attr_mask |= IB_QP_SMAC;
2109 cmd.attr_mask |= IB_QP_VID;
2112 if (cmd.comp_mask & IB_UVERBS_QP_ATTR_DCT_KEY)
2113 attrx->dct_key = cmd.dct_key;
2118 modify_qp_mask(qp->qp_type, cmd.attr_mask), &udata);
2119 if (!ret && (cmd.attr_mask & IB_QP_PORT))
2122 ret = ib_modify_qp(qp, attr, modify_qp_mask(qp->qp_type, cmd.attr_mask));
2149 struct ib_uverbs_destroy_qp cmd;
2156 if (copy_from_user(&cmd, buf, sizeof cmd))
2161 uobj = idr_write_uobj(&ib_uverbs_qp_idr, cmd.qp_handle, file->ucontext);
2196 if (copy_to_user((void __user *) (unsigned long) cmd.response,
2207 struct ib_uverbs_post_send cmd;
2216 if (copy_from_user(&cmd, buf, sizeof cmd))
2219 if (in_len < sizeof cmd + cmd.wqe_size * cmd.wr_count +
2220 cmd.sge_count * sizeof (struct ib_uverbs_sge))
2223 if (cmd.wqe_size < sizeof (struct ib_uverbs_send_wr))
2226 user_wr = kmalloc(cmd.wqe_size, GFP_KERNEL);
2230 qp = idr_read_qp(cmd.qp_handle, file->ucontext);
2237 for (i = 0; i < cmd.wr_count; ++i) {
2239 buf + sizeof cmd + i * cmd.wqe_size,
2240 cmd.wqe_size)) {
2245 if (user_wr->num_sge + sg_ind > cmd.sge_count) {
2317 buf + sizeof cmd +
2318 cmd.wr_count * cmd.wqe_size +
2338 if (copy_to_user((void __user *) (unsigned long) cmd.response,
2448 struct ib_uverbs_post_recv cmd;
2454 if (copy_from_user(&cmd, buf, sizeof cmd))
2457 wr = ib_uverbs_unmarshall_recv(buf + sizeof cmd,
2458 in_len - sizeof cmd, cmd.wr_count,
2459 cmd.sge_count, cmd.wqe_size);
2463 qp = idr_read_qp(cmd.qp_handle, file->ucontext);
2479 if (copy_to_user((void __user *) (unsigned long) cmd.response,
2497 struct ib_uverbs_post_srq_recv cmd;
2503 if (copy_from_user(&cmd, buf, sizeof cmd))
2506 wr = ib_uverbs_unmarshall_recv(buf + sizeof cmd,
2507 in_len - sizeof cmd, cmd.wr_count,
2508 cmd.sge_count, cmd.wqe_size);
2512 srq = idr_read_srq(cmd.srq_handle, file->ucontext);
2528 if (copy_to_user((void __user *) (unsigned long) cmd.response,
2546 struct ib_uverbs_create_ah cmd;
2557 if (copy_from_user(&cmd, buf, sizeof cmd))
2564 init_uobj(uobj, cmd.user_handle, file->ucontext, &ah_lock_class);
2567 pd = idr_read_pd(cmd.pd_handle, file->ucontext);
2573 attr.dlid = cmd.attr.dlid;
2574 attr.sl = cmd.attr.sl;
2575 attr.src_path_bits = cmd.attr.src_path_bits;
2576 attr.static_rate = cmd.attr.static_rate;
2577 attr.ah_flags = cmd.attr.is_global ? IB_AH_GRH : 0;
2578 attr.port_num = cmd.attr.port_num;
2579 attr.grh.flow_label = cmd.attr.grh.flow_label;
2580 attr.grh.sgid_index = cmd.attr.grh.sgid_index;
2581 attr.grh.hop_limit = cmd.attr.grh.hop_limit;
2582 attr.grh.traffic_class = cmd.attr.grh.traffic_class;
2583 memcpy(attr.grh.dgid.raw, cmd.attr.grh.dgid, 16);
2600 if (copy_to_user((void __user *) (unsigned long) cmd.response,
2635 struct ib_uverbs_destroy_ah cmd;
2640 if (copy_from_user(&cmd, buf, sizeof cmd))
2643 uobj = idr_write_uobj(&ib_uverbs_ah_idr, cmd.ah_handle, file->ucontext);
2672 struct ib_uverbs_attach_mcast cmd;
2678 if (copy_from_user(&cmd, buf, sizeof cmd))
2681 qp = idr_write_qp(cmd.qp_handle, file->ucontext);
2688 if (cmd.mlid == mcast->lid &&
2689 !memcmp(cmd.gid, mcast->gid.raw, sizeof mcast->gid.raw)) {
2700 mcast->lid = cmd.mlid;
2701 memcpy(mcast->gid.raw, cmd.gid, sizeof mcast->gid.raw);
2703 ret = ib_attach_mcast(qp, &mcast->gid, cmd.mlid);
2719 struct ib_uverbs_detach_mcast cmd;
2725 if (copy_from_user(&cmd, buf, sizeof cmd))
2728 qp = idr_write_qp(cmd.qp_handle, file->ucontext);
2732 ret = ib_detach_mcast(qp, (union ib_gid *) cmd.gid, cmd.mlid);
2739 if (cmd.mlid == mcast->lid &&
2740 !memcmp(cmd.gid, mcast->gid.raw, sizeof mcast->gid.raw)) {
2753 struct ib_uverbs_create_xsrq *cmd,
2768 init_uobj(&obj->uevent.uobject, cmd->user_handle, file->ucontext, &srq_lock_class);
2771 if (cmd->srq_type == IB_SRQT_XRC) {
2772 attr.ext.xrc.xrcd = idr_read_xrcd(cmd->xrcd_handle, file->ucontext, &xrcd_uobj);
2781 attr.ext.xrc.cq = idr_read_cq(cmd->cq_handle, file->ucontext, 0);
2788 pd = idr_read_pd(cmd->pd_handle, file->ucontext);
2796 attr.srq_type = cmd->srq_type;
2797 attr.attr.max_wr = cmd->max_wr;
2798 attr.attr.max_sge = cmd->max_sge;
2799 attr.attr.srq_limit = cmd->srq_limit;
2812 srq->srq_type = cmd->srq_type;
2817 if (cmd->srq_type == IB_SRQT_XRC) {
2836 if (cmd->srq_type == IB_SRQT_XRC)
2839 if (copy_to_user((void __user *) (unsigned long) cmd->response,
2845 if (cmd->srq_type == IB_SRQT_XRC) {
2871 if (cmd->srq_type == IB_SRQT_XRC)
2875 if (cmd->srq_type == IB_SRQT_XRC) {
2889 struct ib_uverbs_create_srq cmd;
2898 if (copy_from_user(&cmd, buf, sizeof cmd))
2901 xcmd.response = cmd.response;
2902 xcmd.user_handle = cmd.user_handle;
2904 xcmd.pd_handle = cmd.pd_handle;
2905 xcmd.max_wr = cmd.max_wr;
2906 xcmd.max_sge = cmd.max_sge;
2907 xcmd.srq_limit = cmd.srq_limit;
2909 INIT_UDATA(&udata, buf + sizeof cmd,
2910 (unsigned long) cmd.response + sizeof resp,
2911 in_len - sizeof cmd, out_len - sizeof resp);
2923 struct ib_uverbs_create_xsrq cmd;
2931 if (copy_from_user(&cmd, buf, sizeof cmd))
2934 INIT_UDATA(&udata, buf + sizeof cmd,
2935 (unsigned long) cmd.response + sizeof resp,
2936 in_len - sizeof cmd, out_len - sizeof resp);
2938 ret = __uverbs_create_xsrq(file, &cmd, &udata);
2949 struct ib_uverbs_modify_srq cmd;
2955 if (copy_from_user(&cmd, buf, sizeof cmd))
2958 INIT_UDATA(&udata, buf + sizeof cmd, NULL, in_len - sizeof cmd,
2961 srq = idr_read_srq(cmd.srq_handle, file->ucontext);
2965 attr.max_wr = cmd.max_wr;
2966 attr.srq_limit = cmd.srq_limit;
2968 ret = srq->device->modify_srq(srq, &attr, cmd.attr_mask, &udata);
2979 struct ib_uverbs_query_srq cmd;
2988 if (copy_from_user(&cmd, buf, sizeof cmd))
2991 srq = idr_read_srq(cmd.srq_handle, file->ucontext);
3008 if (copy_to_user((void __user *) (unsigned long) cmd.response,
3019 struct ib_uverbs_destroy_srq cmd;
3028 if (copy_from_user(&cmd, buf, sizeof cmd))
3031 uobj = idr_write_uobj(&ib_uverbs_srq_idr, cmd.srq_handle, file->ucontext);
3065 if (copy_to_user((void __user *) (unsigned long) cmd.response,
3078 struct ib_uverbs_create_dct cmd;
3092 ret = ucore->ops->copy_from(&cmd, ucore, sizeof(cmd));
3100 init_uobj(&obj->uobject, cmd.user_handle, file->ucontext,
3104 pd = idr_read_pd(cmd.pd_handle, file->ucontext);
3110 cq = idr_read_cq(cmd.cq_handle, file->ucontext, 0);
3116 srq = idr_read_srq(cmd.srq_handle, file->ucontext);
3123 attr.access_flags = cmd.access_flags;
3124 attr.min_rnr_timer = cmd.min_rnr_timer;
3126 attr.tclass = cmd.tclass;
3127 attr.flow_label = cmd.flow_label;
3128 attr.dc_key = cmd.dc_key;
3129 attr.mtu = cmd.mtu;
3130 attr.port = cmd.port;
3131 attr.pkey_index = cmd.pkey_index;
3132 attr.gid_index = cmd.gid_index;
3133 attr.hop_limit = cmd.hop_limit;
3134 attr.create_flags = cmd.create_flags;
3198 struct ib_uverbs_destroy_dct cmd;
3208 ret = ucore->ops->copy_from(&cmd, ucore, sizeof(cmd));
3212 uobj = idr_write_uobj(&ib_uverbs_dct_idr, cmd.user_handle, file->ucontext);
3251 struct ib_uverbs_query_dct cmd;
3260 err = ucore->ops->copy_from(&cmd, ucore, sizeof(cmd));
3270 dct = idr_read_dct(cmd.dct_handle, file->ucontext);
3357 struct ib_uverbs_create_flow cmd;
3372 err = ib_copy_from_udata(&cmd, ucore, sizeof(cmd));
3376 ucore->inbuf += sizeof(cmd);
3377 ucore->inlen -= sizeof(cmd);
3379 if (cmd.comp_mask)
3385 if (cmd.flow_attr.num_of_specs > IB_FLOW_SPEC_SUPPORT_LAYERS)
3388 if (cmd.flow_attr.size > ucore->inlen ||
3389 cmd.flow_attr.size >
3390 (cmd.flow_attr.num_of_specs * sizeof(struct ib_uverbs_flow_spec)))
3393 if (cmd.flow_attr.num_of_specs) {
3395 cmd.flow_attr.size, GFP_KERNEL);
3399 memcpy(kern_flow_attr, &cmd.flow_attr, sizeof(*kern_flow_attr));
3401 cmd.flow_attr.size);
3405 kern_flow_attr = &cmd.flow_attr;
3416 qp = idr_read_qp(cmd.qp_handle, file->ucontext);
3422 flow_attr = kmalloc(sizeof(*flow_attr) + cmd.flow_attr.size,
3439 cmd.flow_attr.size >
3441 cmd.flow_attr.size >=
3448 cmd.flow_attr.size -=
3453 if (cmd.flow_attr.size || (i != flow_attr->num_of_specs)) {
3454 pr_warn("create flow failed, flow %d: %d bytes left from uverb cmd\n",
3455 i, cmd.flow_attr.size);
3488 if (cmd.flow_attr.num_of_specs)
3502 if (cmd.flow_attr.num_of_specs)
3511 struct ib_uverbs_destroy_flow cmd;
3516 ret = ib_copy_from_udata(&cmd, ucore, sizeof(cmd));
3520 uobj = idr_write_uobj(&ib_uverbs_rule_idr, cmd.flow_handle,
3561 struct ib_uverbs_create_cq_ex cmd;
3563 if (copy_from_user(&cmd, buf, sizeof(cmd)))
3566 return create_cq(file, buf, in_len, out_len, &cmd,
3575 struct ib_uverbs_modify_cq_ex cmd;
3580 if (copy_from_user(&cmd, buf, sizeof(cmd)))
3583 cq = idr_read_cq(cmd.cq_handle, file->ucontext, 0);
3587 attr.moderation.cq_count = cmd.cq_count;
3588 attr.moderation.cq_period = cmd.cq_period;
3589 attr.cq_cap_flags = cmd.cq_cap_flags;
3591 ret = ib_modify_cq(cq, &attr, cmd.attr_mask);