Lines Matching refs:call
44 void __rxrpc_propose_ACK(struct rxrpc_call *call, u8 ack_reason,
53 call->debug_id, rxrpc_acks[ack_reason], ntohl(serial),
56 if (prior < rxrpc_ack_priority[call->ackr_reason]) {
64 if (prior == rxrpc_ack_priority[call->ackr_reason]) {
66 call->ackr_serial = serial;
72 call->ackr_reason = ack_reason;
73 call->ackr_serial = serial;
78 call->ack_timer.expires = jiffies + rxrpc_ack_timeout * HZ;
79 add_timer(&call->ack_timer);
106 if (!timer_pending(&call->ack_timer) ||
107 time_after(call->ack_timer.expires, expiry))
108 mod_timer(&call->ack_timer, expiry);
113 try_to_del_timer_sync(&call->ack_timer);
114 read_lock_bh(&call->state_lock);
115 if (call->state <= RXRPC_CALL_COMPLETE &&
116 !test_and_set_bit(RXRPC_CALL_ACK, &call->events))
117 rxrpc_queue_call(call);
118 read_unlock_bh(&call->state_lock);
122 * propose an ACK be sent, locking the call structure
124 void rxrpc_propose_ACK(struct rxrpc_call *call, u8 ack_reason,
129 if (prior > rxrpc_ack_priority[call->ackr_reason]) {
130 spin_lock_bh(&call->lock);
131 __rxrpc_propose_ACK(call, ack_reason, serial, immediate);
132 spin_unlock_bh(&call->lock);
139 static void rxrpc_set_resend(struct rxrpc_call *call, u8 resend,
142 read_lock_bh(&call->state_lock);
143 if (call->state >= RXRPC_CALL_COMPLETE)
148 set_bit(RXRPC_CALL_RESEND, &call->events);
153 set_bit(RXRPC_CALL_RUN_RTIMER, &call->flags);
154 mod_timer(&call->resend_timer, resend_at);
157 del_timer_sync(&call->resend_timer);
158 clear_bit(RXRPC_CALL_RESEND_TIMER, &call->events);
159 clear_bit(RXRPC_CALL_RUN_RTIMER, &call->flags);
161 read_unlock_bh(&call->state_lock);
167 static void rxrpc_resend(struct rxrpc_call *call)
177 call->acks_hard, call->acks_unacked,
178 atomic_read(&call->sequence),
179 CIRC_CNT(call->acks_head, call->acks_tail, call->acks_winsz));
185 for (loop = call->acks_tail;
186 loop != call->acks_head || stop;
187 loop = (loop + 1) & (call->acks_winsz - 1)
189 p_txb = call->acks_window + loop;
202 htonl(atomic_inc_return(&call->conn->serial));
209 if (rxrpc_send_packet(call->conn->trans, txb) < 0) {
230 rxrpc_set_resend(call, resend, resend_at);
237 static void rxrpc_resend_timer(struct rxrpc_call *call)
246 call->acks_tail, call->acks_unacked, call->acks_head);
248 if (call->state >= RXRPC_CALL_COMPLETE)
254 for (loop = call->acks_unacked;
255 loop != call->acks_head;
256 loop = (loop + 1) & (call->acks_winsz - 1)
258 p_txb = call->acks_window + loop;
279 rxrpc_set_resend(call, resend, resend_at);
288 static int rxrpc_process_soft_ACKs(struct rxrpc_call *call,
299 call->acks_hard,
300 CIRC_CNT(call->acks_head, call->acks_tail, call->acks_winsz),
309 p_txb = call->acks_window;
310 p_txb += (call->acks_tail + loop) & (call->acks_winsz - 1);
332 call->acks_unacked = (call->acks_tail + loop) & (call->acks_winsz - 1);
336 for (loop = call->acks_unacked;
337 loop != call->acks_head;
338 loop = (loop + 1) & (call->acks_winsz - 1)
340 p_txb = call->acks_window + loop;
364 rxrpc_set_resend(call, resend, resend_at);
376 static void rxrpc_rotate_tx_window(struct rxrpc_call *call, u32 hard)
380 int tail = call->acks_tail, old_tail;
381 int win = CIRC_CNT(call->acks_head, tail, call->acks_winsz);
383 _enter("{%u,%u},%u", call->acks_hard, win, hard);
385 ASSERTCMP(hard - call->acks_hard, <=, win);
387 while (call->acks_hard < hard) {
389 _skb = call->acks_window[tail] & ~1;
393 tail = (tail + 1) & (call->acks_winsz - 1);
394 call->acks_tail = tail;
395 if (call->acks_unacked == old_tail)
396 call->acks_unacked = tail;
397 call->acks_hard++;
400 wake_up(&call->tx_waitq);
406 static void rxrpc_clear_tx_window(struct rxrpc_call *call)
408 rxrpc_rotate_tx_window(call, atomic_read(&call->sequence));
414 static int rxrpc_drain_rx_oos_queue(struct rxrpc_call *call)
421 _enter("{%d,%d}", call->rx_data_post, call->rx_first_oos);
423 spin_lock_bh(&call->lock);
426 if (test_bit(RXRPC_CALL_RELEASED, &call->flags))
429 skb = skb_dequeue(&call->rx_oos_queue);
434 ntohl(sp->hdr.seq), call->rx_first_oos);
436 if (ntohl(sp->hdr.seq) != call->rx_first_oos) {
437 skb_queue_head(&call->rx_oos_queue, skb);
438 call->rx_first_oos = ntohl(rxrpc_skb(skb)->hdr.seq);
439 _debug("requeue %p {%u}", skb, call->rx_first_oos);
444 ret = rxrpc_queue_rcv_skb(call, skb, true, terminal);
446 _debug("drain #%u", call->rx_data_post);
447 call->rx_data_post++;
450 skb = skb_peek(&call->rx_oos_queue);
452 call->rx_first_oos =
455 call->rx_first_oos = 0;
456 _debug("peek %p {%u}", skb, call->rx_first_oos);
462 spin_unlock_bh(&call->lock);
470 static void rxrpc_insert_oos_packet(struct rxrpc_call *call,
482 ASSERTCMP(sp->call, ==, NULL);
483 sp->call = call;
484 rxrpc_get_call(call);
487 spin_lock_bh(&call->lock);
489 skb_queue_walk(&call->rx_oos_queue, p) {
494 skb_insert(p, skb, &call->rx_oos_queue);
500 skb_queue_tail(&call->rx_oos_queue, skb);
504 if (call->rx_first_oos == 0 || seq < call->rx_first_oos)
505 call->rx_first_oos = seq;
507 read_lock(&call->state_lock);
508 if (call->state < RXRPC_CALL_COMPLETE &&
509 call->rx_data_post == call->rx_first_oos) {
511 set_bit(RXRPC_CALL_DRAIN_RX_OOS, &call->events);
513 read_unlock(&call->state_lock);
515 spin_unlock_bh(&call->lock);
516 _leave(" [stored #%u]", call->rx_first_oos);
522 static void rxrpc_zap_tx_window(struct rxrpc_call *call)
527 u8 winsz = call->acks_winsz;
530 acks_window = call->acks_window;
531 call->acks_window = NULL;
533 while (CIRC_CNT(call->acks_head, call->acks_tail, winsz) > 0) {
534 tail = call->acks_tail;
538 call->acks_tail = (call->acks_tail + 1) & (winsz - 1);
552 static void rxrpc_extract_ackinfo(struct rxrpc_call *call, struct sk_buff *skb,
571 peer = call->conn->trans->peer;
584 static int rxrpc_process_rx_queue(struct rxrpc_call *call,
597 skb = skb_dequeue(&call->rx_queue);
605 _debug("process %s [st %d]", rxrpc_pkts[sp->hdr.type], call->state);
617 if (rxrpc_verify_packet(call, skb, _abort_code) < 0)
620 rxrpc_insert_oos_packet(call, skb);
634 tx = atomic_read(&call->sequence);
645 rxrpc_extract_ackinfo(call, skb, latest, ack.nAcks);
649 rxrpc_propose_ACK(call, RXRPC_ACK_PING_RESPONSE,
654 if (latest - call->acks_latest <= 0) {
656 latest, call->acks_latest);
659 call->acks_latest = latest;
661 if (call->state != RXRPC_CALL_CLIENT_SEND_REQUEST &&
662 call->state != RXRPC_CALL_CLIENT_AWAIT_REPLY &&
663 call->state != RXRPC_CALL_SERVER_SEND_REPLY &&
664 call->state != RXRPC_CALL_SERVER_AWAIT_ACK)
667 _debug("Tx=%d H=%u S=%d", tx, call->acks_hard, call->state);
677 if ((call->state == RXRPC_CALL_CLIENT_AWAIT_REPLY ||
678 call->state == RXRPC_CALL_SERVER_AWAIT_ACK) &&
683 rxrpc_rotate_tx_window(call, hard - 1);
694 if (rxrpc_process_soft_ACKs(call, &ack, skb) < 0)
718 write_lock_bh(&call->state_lock);
719 _debug("ack all %d", call->state);
721 switch (call->state) {
723 call->state = RXRPC_CALL_CLIENT_RECV_REPLY;
727 call->state = RXRPC_CALL_COMPLETE;
734 write_unlock_bh(&call->state_lock);
738 write_unlock_bh(&call->state_lock);
743 CIRC_CNT(call->acks_head, call->acks_tail, call->acks_winsz));
745 del_timer_sync(&call->resend_timer);
746 clear_bit(RXRPC_CALL_RUN_RTIMER, &call->flags);
747 clear_bit(RXRPC_CALL_RESEND_TIMER, &call->events);
749 if (call->acks_window)
750 rxrpc_zap_tx_window(call);
756 sp->call = call;
757 rxrpc_get_call(call);
758 spin_lock_bh(&call->lock);
759 if (rxrpc_queue_rcv_skb(call, skb, true, true) < 0)
761 spin_unlock_bh(&call->lock);
770 write_unlock_bh(&call->state_lock);
780 static int rxrpc_post_message(struct rxrpc_call *call, u32 mark, u32 error,
788 call->debug_id, call->flags, mark, error, fatal);
792 del_timer_sync(&call->resend_timer);
793 del_timer_sync(&call->ack_timer);
794 clear_bit(RXRPC_CALL_RUN_RTIMER, &call->flags);
798 !test_bit(RXRPC_CALL_HAS_USERID, &call->flags)) {
803 if (!test_bit(RXRPC_CALL_TERMINAL_MSG, &call->flags)) {
815 sp->call = call;
816 rxrpc_get_call(call);
818 spin_lock_bh(&call->lock);
819 ret = rxrpc_queue_rcv_skb(call, skb, true, fatal);
820 spin_unlock_bh(&call->lock);
828 * handle background processing of incoming call packets and ACK / abort
833 struct rxrpc_call *call =
849 call->debug_id, rxrpc_call_states[call->state], call->events,
850 (jiffies - call->creation_jif) / (HZ / 10));
852 if (test_and_set_bit(RXRPC_CALL_PROC_BUSY, &call->flags)) {
859 msg.msg_name = &call->conn->trans->peer->srx.transport.sin;
860 msg.msg_namelen = sizeof(call->conn->trans->peer->srx.transport.sin);
865 hdr.epoch = call->conn->epoch;
866 hdr.cid = call->cid;
867 hdr.callNumber = call->call_id;
870 hdr.flags = call->conn->out_clientflag;
872 hdr.securityIndex = call->conn->security_ix;
874 hdr.serviceId = call->conn->service_id;
881 if (test_bit(RXRPC_CALL_RELEASE, &call->events)) {
882 rxrpc_release_call(call);
883 clear_bit(RXRPC_CALL_RELEASE, &call->events);
886 if (test_bit(RXRPC_CALL_RCVD_ERROR, &call->events)) {
889 clear_bit(RXRPC_CALL_CONN_ABORT, &call->events);
890 clear_bit(RXRPC_CALL_REJECT_BUSY, &call->events);
891 clear_bit(RXRPC_CALL_ABORT, &call->events);
893 error = call->conn->trans->peer->net_error;
896 if (rxrpc_post_message(call, RXRPC_SKB_MARK_NET_ERROR,
899 clear_bit(RXRPC_CALL_RCVD_ERROR, &call->events);
903 if (test_bit(RXRPC_CALL_CONN_ABORT, &call->events)) {
904 ASSERTCMP(call->state, >, RXRPC_CALL_COMPLETE);
906 clear_bit(RXRPC_CALL_REJECT_BUSY, &call->events);
907 clear_bit(RXRPC_CALL_ABORT, &call->events);
911 if (rxrpc_post_message(call, RXRPC_SKB_MARK_LOCAL_ERROR,
912 call->conn->error, true) < 0)
914 clear_bit(RXRPC_CALL_CONN_ABORT, &call->events);
918 if (test_bit(RXRPC_CALL_REJECT_BUSY, &call->events)) {
924 if (test_bit(RXRPC_CALL_ABORT, &call->events)) {
925 ASSERTCMP(call->state, >, RXRPC_CALL_COMPLETE);
927 if (rxrpc_post_message(call, RXRPC_SKB_MARK_LOCAL_ERROR,
931 data = htonl(call->abort_code);
938 if (test_bit(RXRPC_CALL_ACK_FINAL, &call->events)) {
946 call->ackr_reason = 0;
948 spin_lock_bh(&call->lock);
949 ack.serial = call->ackr_serial;
950 ack.previousPacket = call->ackr_prev_seq;
951 ack.firstPacket = htonl(call->rx_data_eaten + 1);
952 spin_unlock_bh(&call->lock);
965 if (call->events & ((1 << RXRPC_CALL_RCVD_BUSY) |
970 if (test_bit(RXRPC_CALL_RCVD_ABORT, &call->events))
976 rxrpc_clear_tx_window(call);
977 if (rxrpc_post_message(call, mark, ECONNABORTED, true) < 0)
980 clear_bit(RXRPC_CALL_RCVD_BUSY, &call->events);
981 clear_bit(RXRPC_CALL_RCVD_ABORT, &call->events);
985 if (test_and_clear_bit(RXRPC_CALL_RCVD_ACKALL, &call->events)) {
987 rxrpc_clear_tx_window(call);
990 if (test_bit(RXRPC_CALL_LIFE_TIMER, &call->events)) {
991 write_lock_bh(&call->state_lock);
992 if (call->state <= RXRPC_CALL_COMPLETE) {
993 call->state = RXRPC_CALL_LOCALLY_ABORTED;
994 call->abort_code = RX_CALL_TIMEOUT;
995 set_bit(RXRPC_CALL_ABORT, &call->events);
997 write_unlock_bh(&call->state_lock);
1000 if (rxrpc_post_message(call, RXRPC_SKB_MARK_LOCAL_ERROR,
1004 clear_bit(RXRPC_CALL_LIFE_TIMER, &call->events);
1009 if (!skb_queue_empty(&call->rx_queue)) {
1010 switch (rxrpc_process_rx_queue(call, &abort_code)) {
1019 rxrpc_abort_call(call, abort_code);
1025 if (test_and_clear_bit(RXRPC_CALL_RESEND_TIMER, &call->events))
1026 rxrpc_resend_timer(call);
1027 if (test_and_clear_bit(RXRPC_CALL_RESEND, &call->events))
1028 rxrpc_resend(call);
1031 if (test_bit(RXRPC_CALL_ACK, &call->events)) {
1033 call->rx_data_eaten, call->ackr_win_top,
1034 call->ackr_window[0]);
1036 if (call->state > RXRPC_CALL_SERVER_ACK_REQUEST &&
1037 call->ackr_reason != RXRPC_ACK_PING_RESPONSE) {
1039 clear_bit(RXRPC_CALL_ACK, &call->events);
1045 acks = kzalloc(call->ackr_win_top - call->rx_data_eaten,
1056 spin_lock_bh(&call->lock);
1057 ack.reason = call->ackr_reason;
1058 ack.serial = call->ackr_serial;
1059 ack.previousPacket = call->ackr_prev_seq;
1060 ack.firstPacket = htonl(call->rx_data_eaten + 1);
1065 for (bits = call->ackr_window[loop]; bits; bits >>= 1
1075 call->ackr_reason = 0;
1076 spin_unlock_bh(&call->lock);
1106 if (test_and_clear_bit(RXRPC_CALL_SECURED, &call->events)) {
1108 spin_lock_bh(&call->lock);
1110 if (call->state == RXRPC_CALL_SERVER_SECURING) {
1112 write_lock(&call->conn->lock);
1113 if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&
1114 !test_bit(RXRPC_CALL_RELEASE, &call->events)) {
1116 call->state = RXRPC_CALL_SERVER_ACCEPTING;
1117 list_move_tail(&call->accept_link,
1118 &call->socket->acceptq);
1120 write_unlock(&call->conn->lock);
1121 read_lock(&call->state_lock);
1122 if (call->state < RXRPC_CALL_COMPLETE)
1123 set_bit(RXRPC_CALL_POST_ACCEPT, &call->events);
1124 read_unlock(&call->state_lock);
1127 spin_unlock_bh(&call->lock);
1128 if (!test_bit(RXRPC_CALL_POST_ACCEPT, &call->events))
1133 if (test_bit(RXRPC_CALL_POST_ACCEPT, &call->events)) {
1135 if (rxrpc_post_message(call, RXRPC_SKB_MARK_NEW_CALL,
1138 clear_bit(RXRPC_CALL_POST_ACCEPT, &call->events);
1142 /* handle incoming call acceptance */
1143 if (test_and_clear_bit(RXRPC_CALL_ACCEPTED, &call->events)) {
1145 ASSERTCMP(call->rx_data_post, ==, 0);
1146 call->rx_data_post = 1;
1147 read_lock_bh(&call->state_lock);
1148 if (call->state < RXRPC_CALL_COMPLETE)
1149 set_bit(RXRPC_CALL_DRAIN_RX_OOS, &call->events);
1150 read_unlock_bh(&call->state_lock);
1155 if (test_and_clear_bit(RXRPC_CALL_DRAIN_RX_OOS, &call->events)) {
1156 while (call->rx_data_post == call->rx_first_oos)
1157 if (rxrpc_drain_rx_oos_queue(call) < 0)
1166 ack.maxSkew = htons(atomic_read(&call->conn->hi_serial) -
1169 mtu = call->conn->trans->peer->if_mtu;
1170 mtu -= call->conn->trans->peer->hdrsize;
1178 hdr.serial = htonl(atomic_inc_return(&call->conn->serial));
1188 del_timer_sync(&call->ack_timer);
1190 set_bit(RXRPC_CALL_TX_SOFT_ACK, &call->flags);
1196 hdr.serial = htonl(atomic_inc_return(&call->conn->serial));
1222 ret = kernel_sendmsg(call->conn->trans->local->socket,
1226 read_lock_bh(&call->state_lock);
1227 if (call->state < RXRPC_CALL_DEAD)
1228 rxrpc_queue_call(call);
1229 read_unlock_bh(&call->state_lock);
1235 clear_bit(genbit, &call->events);
1236 clear_bit(RXRPC_CALL_RCVD_ABORT, &call->events);
1240 write_lock_bh(&call->state_lock);
1241 if (call->state == RXRPC_CALL_CLIENT_FINAL_ACK)
1242 call->state = RXRPC_CALL_COMPLETE;
1243 write_unlock_bh(&call->state_lock);
1247 clear_bit(genbit, &call->events);
1248 switch (call->state) {
1254 rxrpc_propose_ACK(call, RXRPC_ACK_DELAY,
1255 call->ackr_serial, false);
1263 del_timer_sync(&call->ack_timer);
1264 if (test_and_clear_bit(RXRPC_CALL_ACK_FINAL, &call->events))
1265 rxrpc_put_call(call);
1266 clear_bit(RXRPC_CALL_ACK, &call->events);
1269 if (call->events || !skb_queue_empty(&call->rx_queue)) {
1270 read_lock_bh(&call->state_lock);
1271 if (call->state < RXRPC_CALL_DEAD)
1272 rxrpc_queue_call(call);
1273 read_unlock_bh(&call->state_lock);
1277 if (call->state >= RXRPC_CALL_COMPLETE &&
1278 !list_empty(&call->accept_link)) {
1279 _debug("X unlinking once-pending call %p { e=%lx f=%lx c=%x }",
1280 call, call->events, call->flags,
1281 ntohl(call->conn->cid));
1283 read_lock_bh(&call->state_lock);
1284 if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&
1285 !test_and_set_bit(RXRPC_CALL_RELEASE, &call->events))
1286 rxrpc_queue_call(call);
1287 read_unlock_bh(&call->state_lock);
1291 clear_bit(RXRPC_CALL_PROC_BUSY, &call->flags);
1295 * call at the same time, we use a flag to note when it's busy; however
1298 if (call->events && !work_pending(&call->processor)) {
1299 _debug("jumpstart %x", ntohl(call->conn->cid));
1300 rxrpc_queue_call(call);