Lines Matching defs:rmpp_recv
72 static inline void deref_rmpp_recv(struct mad_rmpp_recv *rmpp_recv)
74 if (atomic_dec_and_test(&rmpp_recv->refcount))
75 complete(&rmpp_recv->comp);
78 static void destroy_rmpp_recv(struct mad_rmpp_recv *rmpp_recv)
80 deref_rmpp_recv(rmpp_recv);
81 wait_for_completion(&rmpp_recv->comp);
82 ib_destroy_ah(rmpp_recv->ah);
83 kfree(rmpp_recv);
88 struct mad_rmpp_recv *rmpp_recv, *temp_rmpp_recv;
92 list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) {
93 if (rmpp_recv->state != RMPP_STATE_COMPLETE)
94 ib_free_recv_mad(rmpp_recv->rmpp_wc);
95 rmpp_recv->state = RMPP_STATE_CANCELING;
99 list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) {
100 cancel_delayed_work(&rmpp_recv->timeout_work);
101 cancel_delayed_work(&rmpp_recv->cleanup_work);
106 list_for_each_entry_safe(rmpp_recv, temp_rmpp_recv,
108 list_del(&rmpp_recv->list);
109 destroy_rmpp_recv(rmpp_recv);
115 struct mad_rmpp_recv *rmpp_recv)
126 spin_lock_irqsave(&rmpp_recv->lock, flags);
127 rmpp_recv->last_ack = rmpp_recv->seg_num;
128 ack->rmpp_hdr.seg_num = cpu_to_be32(rmpp_recv->seg_num);
129 ack->rmpp_hdr.paylen_newwin = cpu_to_be32(rmpp_recv->newwin);
130 spin_unlock_irqrestore(&rmpp_recv->lock, flags);
133 static void ack_recv(struct mad_rmpp_recv *rmpp_recv,
140 msg = ib_create_send_mad(&rmpp_recv->agent->agent, recv_wc->wc->src_qp,
146 format_ack(msg, (struct ib_rmpp_mad *) recv_wc->recv_buf.mad, rmpp_recv);
147 msg->ah = rmpp_recv->ah;
243 struct mad_rmpp_recv *rmpp_recv =
248 spin_lock_irqsave(&rmpp_recv->agent->lock, flags);
249 if (rmpp_recv->state != RMPP_STATE_ACTIVE) {
250 spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags);
253 rmpp_recv->state = RMPP_STATE_TIMEOUT;
254 list_del(&rmpp_recv->list);
255 spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags);
257 rmpp_wc = rmpp_recv->rmpp_wc;
258 nack_recv(rmpp_recv->agent, rmpp_wc, IB_MGMT_RMPP_STATUS_T2L);
259 destroy_rmpp_recv(rmpp_recv);
265 struct mad_rmpp_recv *rmpp_recv =
269 spin_lock_irqsave(&rmpp_recv->agent->lock, flags);
270 if (rmpp_recv->state == RMPP_STATE_CANCELING) {
271 spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags);
274 list_del(&rmpp_recv->list);
275 spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags);
276 destroy_rmpp_recv(rmpp_recv);
283 struct mad_rmpp_recv *rmpp_recv;
286 rmpp_recv = kmalloc(sizeof *rmpp_recv, GFP_KERNEL);
287 if (!rmpp_recv)
290 rmpp_recv->ah = ib_create_ah_from_wc(agent->agent.qp->pd,
294 if (IS_ERR(rmpp_recv->ah))
297 rmpp_recv->agent = agent;
298 init_completion(&rmpp_recv->comp);
299 INIT_DELAYED_WORK(&rmpp_recv->timeout_work, recv_timeout_handler);
300 INIT_DELAYED_WORK(&rmpp_recv->cleanup_work, recv_cleanup_handler);
301 spin_lock_init(&rmpp_recv->lock);
302 rmpp_recv->state = RMPP_STATE_ACTIVE;
303 atomic_set(&rmpp_recv->refcount, 1);
305 rmpp_recv->rmpp_wc = mad_recv_wc;
306 rmpp_recv->cur_seg_buf = &mad_recv_wc->recv_buf;
307 rmpp_recv->newwin = 1;
308 rmpp_recv->seg_num = 1;
309 rmpp_recv->last_ack = 0;
310 rmpp_recv->repwin = 1;
313 rmpp_recv->tid = mad_hdr->tid;
314 rmpp_recv->src_qp = mad_recv_wc->wc->src_qp;
315 rmpp_recv->slid = mad_recv_wc->wc->slid;
316 rmpp_recv->mgmt_class = mad_hdr->mgmt_class;
317 rmpp_recv->class_version = mad_hdr->class_version;
318 rmpp_recv->method = mad_hdr->method;
319 return rmpp_recv;
321 error: kfree(rmpp_recv);
329 struct mad_rmpp_recv *rmpp_recv;
332 list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) {
333 if (rmpp_recv->tid == mad_hdr->tid &&
334 rmpp_recv->src_qp == mad_recv_wc->wc->src_qp &&
335 rmpp_recv->slid == mad_recv_wc->wc->slid &&
336 rmpp_recv->mgmt_class == mad_hdr->mgmt_class &&
337 rmpp_recv->class_version == mad_hdr->class_version &&
338 rmpp_recv->method == mad_hdr->method)
339 return rmpp_recv;
348 struct mad_rmpp_recv *rmpp_recv;
352 rmpp_recv = find_rmpp_recv(agent, mad_recv_wc);
353 if (rmpp_recv)
354 atomic_inc(&rmpp_recv->refcount);
356 return rmpp_recv;
361 struct mad_rmpp_recv *rmpp_recv)
365 cur_rmpp_recv = find_rmpp_recv(agent, rmpp_recv->rmpp_wc);
367 list_add_tail(&rmpp_recv->list, &agent->rmpp_list);
418 static void update_seg_num(struct mad_rmpp_recv *rmpp_recv,
421 struct list_head *rmpp_list = &rmpp_recv->rmpp_wc->rmpp_list;
423 while (new_buf && (get_seg_num(new_buf) == rmpp_recv->seg_num + 1)) {
424 rmpp_recv->cur_seg_buf = new_buf;
425 rmpp_recv->seg_num++;
430 static inline int get_mad_len(struct mad_rmpp_recv *rmpp_recv)
435 rmpp_mad = (struct ib_rmpp_mad *)rmpp_recv->cur_seg_buf->mad;
443 return hdr_size + rmpp_recv->seg_num * data_size - pad;
446 static struct ib_mad_recv_wc * complete_rmpp(struct mad_rmpp_recv *rmpp_recv)
450 ack_recv(rmpp_recv, rmpp_recv->rmpp_wc);
451 if (rmpp_recv->seg_num > 1)
452 cancel_delayed_work(&rmpp_recv->timeout_work);
454 rmpp_wc = rmpp_recv->rmpp_wc;
455 rmpp_wc->mad_len = get_mad_len(rmpp_recv);
457 queue_delayed_work(rmpp_recv->agent->qp_info->port_priv->wq,
458 &rmpp_recv->cleanup_work, msecs_to_jiffies(10000));
466 struct mad_rmpp_recv *rmpp_recv;
472 rmpp_recv = acquire_rmpp_recv(agent, mad_recv_wc);
473 if (!rmpp_recv)
478 spin_lock_irqsave(&rmpp_recv->lock, flags);
479 if ((rmpp_recv->state == RMPP_STATE_TIMEOUT) ||
480 (seg_num > rmpp_recv->newwin))
483 if ((seg_num <= rmpp_recv->last_ack) ||
484 (rmpp_recv->state == RMPP_STATE_COMPLETE)) {
485 spin_unlock_irqrestore(&rmpp_recv->lock, flags);
486 ack_recv(rmpp_recv, mad_recv_wc);
490 prev_buf = find_seg_location(&rmpp_recv->rmpp_wc->rmpp_list, seg_num);
496 if (rmpp_recv->cur_seg_buf == prev_buf) {
497 update_seg_num(rmpp_recv, &mad_recv_wc->recv_buf);
498 if (get_last_flag(rmpp_recv->cur_seg_buf)) {
499 rmpp_recv->state = RMPP_STATE_COMPLETE;
500 spin_unlock_irqrestore(&rmpp_recv->lock, flags);
501 done_wc = complete_rmpp(rmpp_recv);
503 } else if (rmpp_recv->seg_num == rmpp_recv->newwin) {
504 rmpp_recv->newwin += window_size(agent);
505 spin_unlock_irqrestore(&rmpp_recv->lock, flags);
506 ack_recv(rmpp_recv, mad_recv_wc);
510 spin_unlock_irqrestore(&rmpp_recv->lock, flags);
512 deref_rmpp_recv(rmpp_recv);
515 drop3: spin_unlock_irqrestore(&rmpp_recv->lock, flags);
516 drop2: deref_rmpp_recv(rmpp_recv);
525 struct mad_rmpp_recv *rmpp_recv;
528 rmpp_recv = create_rmpp_recv(agent, mad_recv_wc);
529 if (!rmpp_recv) {
535 if (insert_rmpp_recv(agent, rmpp_recv)) {
538 destroy_rmpp_recv(rmpp_recv);
541 atomic_inc(&rmpp_recv->refcount);
544 rmpp_recv->state = RMPP_STATE_COMPLETE;
546 complete_rmpp(rmpp_recv);
551 &rmpp_recv->timeout_work,
553 rmpp_recv->newwin += window_size(agent);
554 ack_recv(rmpp_recv, mad_recv_wc);
557 deref_rmpp_recv(rmpp_recv);
634 struct mad_rmpp_recv *rmpp_recv;
636 rmpp_recv = find_rmpp_recv(agent, mad_recv_wc);
637 if (rmpp_recv && rmpp_recv->state == RMPP_STATE_COMPLETE)
638 rmpp_recv->repwin = newwin;
839 struct mad_rmpp_recv *rmpp_recv;
848 list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) {
849 if (rmpp_recv->tid != mad_hdr->tid ||
850 rmpp_recv->mgmt_class != mad_hdr->mgmt_class ||
851 rmpp_recv->class_version != mad_hdr->class_version ||
852 (rmpp_recv->method & IB_MGMT_METHOD_RESP))
858 if (rmpp_recv->slid == ah_attr.dlid) {
859 newwin = rmpp_recv->repwin;