p71924506
/
linux_old1
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
linux_old1/net/rxrpc/call.c

2278 lines
57 KiB
C
Raw Blame History

/* call.c: Rx call routines
*
* Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
* Written by David Howells (dhowells@redhat.com)
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*/
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <rxrpc/rxrpc.h>
#include <rxrpc/transport.h>
#include <rxrpc/peer.h>
#include <rxrpc/connection.h>
#include <rxrpc/call.h>
#include <rxrpc/message.h>
#include "internal.h"
__RXACCT_DECL(atomic_t rxrpc_call_count);
__RXACCT_DECL(atomic_t rxrpc_message_count);
LIST_HEAD(rxrpc_calls);
DECLARE_RWSEM(rxrpc_calls_sem);
unsigned rxrpc_call_rcv_timeout = HZ/3;
static unsigned rxrpc_call_acks_timeout = HZ/3;
static unsigned rxrpc_call_dfr_ack_timeout = HZ/20;
static unsigned short rxrpc_call_max_resend = HZ/10;
const char *rxrpc_call_states[] = {
"COMPLETE",
"ERROR",
"SRVR_RCV_OPID",
"SRVR_RCV_ARGS",
"SRVR_GOT_ARGS",
"SRVR_SND_REPLY",
"SRVR_RCV_FINAL_ACK",
"CLNT_SND_ARGS",
"CLNT_RCV_REPLY",
"CLNT_GOT_REPLY"
};
const char *rxrpc_call_error_states[] = {
"NO_ERROR",
"LOCAL_ABORT",
"PEER_ABORT",
"LOCAL_ERROR",
"REMOTE_ERROR"
};
const char *rxrpc_pkts[] = {
"?00",
"data", "ack", "busy", "abort", "ackall", "chall", "resp", "debug",
"?09", "?10", "?11", "?12", "?13", "?14", "?15"
};
static const char *rxrpc_acks[] = {
"---", "REQ", "DUP", "SEQ", "WIN", "MEM", "PNG", "PNR", "DLY", "IDL",
"-?-"
};
static const char _acktype[] = "NA-";
static void rxrpc_call_receive_packet(struct rxrpc_call *call);
static void rxrpc_call_receive_data_packet(struct rxrpc_call *call,
struct rxrpc_message *msg);
static void rxrpc_call_receive_ack_packet(struct rxrpc_call *call,
struct rxrpc_message *msg);
static void rxrpc_call_definitively_ACK(struct rxrpc_call *call,
rxrpc_seq_t higest);
static void rxrpc_call_resend(struct rxrpc_call *call, rxrpc_seq_t highest);
static int __rxrpc_call_read_data(struct rxrpc_call *call);
static int rxrpc_call_record_ACK(struct rxrpc_call *call,
struct rxrpc_message *msg,
rxrpc_seq_t seq,
size_t count);
static int rxrpc_call_flush(struct rxrpc_call *call);
#define _state(call) \
_debug("[[[ state %s ]]]", rxrpc_call_states[call->app_call_state]);
static void rxrpc_call_default_attn_func(struct rxrpc_call *call)
{
wake_up(&call->waitq);
}
static void rxrpc_call_default_error_func(struct rxrpc_call *call)
{
wake_up(&call->waitq);
}
static void rxrpc_call_default_aemap_func(struct rxrpc_call *call)
{
switch (call->app_err_state) {
case RXRPC_ESTATE_LOCAL_ABORT:
call->app_abort_code = -call->app_errno;
case RXRPC_ESTATE_PEER_ABORT:
call->app_errno = -ECONNABORTED;
default:
break;
}
}
static void __rxrpc_call_acks_timeout(unsigned long _call)
{
struct rxrpc_call *call = (struct rxrpc_call *) _call;
_debug("ACKS TIMEOUT %05lu", jiffies - call->cjif);
call->flags |= RXRPC_CALL_ACKS_TIMO;
rxrpc_krxiod_queue_call(call);
}
static void __rxrpc_call_rcv_timeout(unsigned long _call)
{
struct rxrpc_call *call = (struct rxrpc_call *) _call;
_debug("RCV TIMEOUT %05lu", jiffies - call->cjif);
call->flags |= RXRPC_CALL_RCV_TIMO;
rxrpc_krxiod_queue_call(call);
}
static void __rxrpc_call_ackr_timeout(unsigned long _call)
{
struct rxrpc_call *call = (struct rxrpc_call *) _call;
_debug("ACKR TIMEOUT %05lu",jiffies - call->cjif);
call->flags |= RXRPC_CALL_ACKR_TIMO;
rxrpc_krxiod_queue_call(call);
}
/*****************************************************************************/
/*
* calculate a timeout based on an RTT value
*/
static inline unsigned long __rxrpc_rtt_based_timeout(struct rxrpc_call *call,
unsigned long val)
{
unsigned long expiry = call->conn->peer->rtt / (1000000 / HZ);
expiry += 10;
if (expiry < HZ / 25)
expiry = HZ / 25;
if (expiry > HZ)
expiry = HZ;
_leave(" = %lu jiffies", expiry);
return jiffies + expiry;
} /* end __rxrpc_rtt_based_timeout() */
/*****************************************************************************/
/*
* create a new call record
*/
static inline int __rxrpc_create_call(struct rxrpc_connection *conn,
struct rxrpc_call **_call)
{
struct rxrpc_call *call;
_enter("%p", conn);
/* allocate and initialise a call record */
call = (struct rxrpc_call *) get_zeroed_page(GFP_KERNEL);
if (!call) {
_leave(" ENOMEM");
return -ENOMEM;
}
atomic_set(&call->usage, 1);
init_waitqueue_head(&call->waitq);
spin_lock_init(&call->lock);
INIT_LIST_HEAD(&call->link);
INIT_LIST_HEAD(&call->acks_pendq);
INIT_LIST_HEAD(&call->rcv_receiveq);
INIT_LIST_HEAD(&call->rcv_krxiodq_lk);
INIT_LIST_HEAD(&call->app_readyq);
INIT_LIST_HEAD(&call->app_unreadyq);
INIT_LIST_HEAD(&call->app_link);
INIT_LIST_HEAD(&call->app_attn_link);
init_timer(&call->acks_timeout);
call->acks_timeout.data = (unsigned long) call;
call->acks_timeout.function = __rxrpc_call_acks_timeout;
init_timer(&call->rcv_timeout);
call->rcv_timeout.data = (unsigned long) call;
call->rcv_timeout.function = __rxrpc_call_rcv_timeout;
init_timer(&call->ackr_dfr_timo);
call->ackr_dfr_timo.data = (unsigned long) call;
call->ackr_dfr_timo.function = __rxrpc_call_ackr_timeout;
call->conn = conn;
call->ackr_win_bot = 1;
call->ackr_win_top = call->ackr_win_bot + RXRPC_CALL_ACK_WINDOW_SIZE - 1;
call->ackr_prev_seq = 0;
call->app_mark = RXRPC_APP_MARK_EOF;
call->app_attn_func = rxrpc_call_default_attn_func;
call->app_error_func = rxrpc_call_default_error_func;
call->app_aemap_func = rxrpc_call_default_aemap_func;
call->app_scr_alloc = call->app_scratch;
call->cjif = jiffies;
_leave(" = 0 (%p)", call);
*_call = call;
return 0;
} /* end __rxrpc_create_call() */
/*****************************************************************************/
/*
* create a new call record for outgoing calls
*/
int rxrpc_create_call(struct rxrpc_connection *conn,
rxrpc_call_attn_func_t attn,
rxrpc_call_error_func_t error,
rxrpc_call_aemap_func_t aemap,
struct rxrpc_call **_call)
{
DECLARE_WAITQUEUE(myself, current);
struct rxrpc_call *call;
int ret, cix, loop;
_enter("%p", conn);
/* allocate and initialise a call record */
ret = __rxrpc_create_call(conn, &call);
if (ret < 0) {
_leave(" = %d", ret);
return ret;
}
call->app_call_state = RXRPC_CSTATE_CLNT_SND_ARGS;
if (attn)
call->app_attn_func = attn;
if (error)
call->app_error_func = error;
if (aemap)
call->app_aemap_func = aemap;
_state(call);
spin_lock(&conn->lock);
set_current_state(TASK_INTERRUPTIBLE);
add_wait_queue(&conn->chanwait, &myself);
try_again:
/* try to find an unused channel */
for (cix = 0; cix < 4; cix++)
if (!conn->channels[cix])
goto obtained_chan;
/* no free channels - wait for one to become available */
ret = -EINTR;
if (signal_pending(current))
goto error_unwait;
spin_unlock(&conn->lock);
schedule();
set_current_state(TASK_INTERRUPTIBLE);
spin_lock(&conn->lock);
goto try_again;
/* got a channel - now attach to the connection */
obtained_chan:
remove_wait_queue(&conn->chanwait, &myself);
set_current_state(TASK_RUNNING);
/* concoct a unique call number */
next_callid:
call->call_id = htonl(++conn->call_counter);
for (loop = 0; loop < 4; loop++)
if (conn->channels[loop] &&
conn->channels[loop]->call_id == call->call_id)
goto next_callid;
rxrpc_get_connection(conn);
conn->channels[cix] = call; /* assign _after_ done callid check loop */
do_gettimeofday(&conn->atime);
call->chan_ix = htonl(cix);
spin_unlock(&conn->lock);
down_write(&rxrpc_calls_sem);
list_add_tail(&call->call_link, &rxrpc_calls);
up_write(&rxrpc_calls_sem);
__RXACCT(atomic_inc(&rxrpc_call_count));
*_call = call;
_leave(" = 0 (call=%p cix=%u)", call, cix);
return 0;
error_unwait:
remove_wait_queue(&conn->chanwait, &myself);
set_current_state(TASK_RUNNING);
spin_unlock(&conn->lock);
free_page((unsigned long) call);
_leave(" = %d", ret);
return ret;
} /* end rxrpc_create_call() */
/*****************************************************************************/
/*
* create a new call record for incoming calls
*/
int rxrpc_incoming_call(struct rxrpc_connection *conn,
struct rxrpc_message *msg,
struct rxrpc_call **_call)
{
struct rxrpc_call *call;
unsigned cix;
int ret;
cix = ntohl(msg->hdr.cid) & RXRPC_CHANNELMASK;
_enter("%p,%u,%u", conn, ntohl(msg->hdr.callNumber), cix);
/* allocate and initialise a call record */
ret = __rxrpc_create_call(conn, &call);
if (ret < 0) {
_leave(" = %d", ret);
return ret;
}
call->pkt_rcv_count = 1;
call->app_call_state = RXRPC_CSTATE_SRVR_RCV_OPID;
call->app_mark = sizeof(uint32_t);
_state(call);
/* attach to the connection */
ret = -EBUSY;
call->chan_ix = htonl(cix);
call->call_id = msg->hdr.callNumber;
spin_lock(&conn->lock);
if (!conn->channels[cix] ||
conn->channels[cix]->app_call_state == RXRPC_CSTATE_COMPLETE ||
conn->channels[cix]->app_call_state == RXRPC_CSTATE_ERROR
) {
conn->channels[cix] = call;
rxrpc_get_connection(conn);
ret = 0;
}
spin_unlock(&conn->lock);
if (ret < 0) {
free_page((unsigned long) call);
call = NULL;
}
if (ret == 0) {
down_write(&rxrpc_calls_sem);
list_add_tail(&call->call_link, &rxrpc_calls);
up_write(&rxrpc_calls_sem);
__RXACCT(atomic_inc(&rxrpc_call_count));
*_call = call;
}
_leave(" = %d [%p]", ret, call);
return ret;
} /* end rxrpc_incoming_call() */
/*****************************************************************************/
/*
* free a call record
*/
void rxrpc_put_call(struct rxrpc_call *call)
{
struct rxrpc_connection *conn = call->conn;
struct rxrpc_message *msg;
_enter("%p{u=%d}",call,atomic_read(&call->usage));
/* sanity check */
if (atomic_read(&call->usage) <= 0)
BUG();
/* to prevent a race, the decrement and the de-list must be effectively
* atomic */
spin_lock(&conn->lock);
if (likely(!atomic_dec_and_test(&call->usage))) {
spin_unlock(&conn->lock);
_leave("");
return;
}
if (conn->channels[ntohl(call->chan_ix)] == call)
conn->channels[ntohl(call->chan_ix)] = NULL;
spin_unlock(&conn->lock);
wake_up(&conn->chanwait);
rxrpc_put_connection(conn);
/* clear the timers and dequeue from krxiod */
del_timer_sync(&call->acks_timeout);
del_timer_sync(&call->rcv_timeout);
del_timer_sync(&call->ackr_dfr_timo);
rxrpc_krxiod_dequeue_call(call);
/* clean up the contents of the struct */
if (call->snd_nextmsg)
rxrpc_put_message(call->snd_nextmsg);
if (call->snd_ping)
rxrpc_put_message(call->snd_ping);
while (!list_empty(&call->acks_pendq)) {
msg = list_entry(call->acks_pendq.next,
struct rxrpc_message, link);
list_del(&msg->link);
rxrpc_put_message(msg);
}
while (!list_empty(&call->rcv_receiveq)) {
msg = list_entry(call->rcv_receiveq.next,
struct rxrpc_message, link);
list_del(&msg->link);
rxrpc_put_message(msg);
}
while (!list_empty(&call->app_readyq)) {
msg = list_entry(call->app_readyq.next,
struct rxrpc_message, link);
list_del(&msg->link);
rxrpc_put_message(msg);
}
while (!list_empty(&call->app_unreadyq)) {
msg = list_entry(call->app_unreadyq.next,
struct rxrpc_message, link);
list_del(&msg->link);
rxrpc_put_message(msg);
}
module_put(call->owner);
down_write(&rxrpc_calls_sem);
list_del(&call->call_link);
up_write(&rxrpc_calls_sem);
__RXACCT(atomic_dec(&rxrpc_call_count));
free_page((unsigned long) call);
_leave(" [destroyed]");
} /* end rxrpc_put_call() */
/*****************************************************************************/
/*
* actually generate a normal ACK
*/
static inline int __rxrpc_call_gen_normal_ACK(struct rxrpc_call *call,
rxrpc_seq_t seq)
{
struct rxrpc_message *msg;
struct kvec diov[3];
__be32 aux[4];
int delta, ret;
/* ACKs default to DELAY */
if (!call->ackr.reason)
call->ackr.reason = RXRPC_ACK_DELAY;
_proto("Rx %05lu Sending ACK { m=%hu f=#%u p=#%u s=%%%u r=%s n=%u }",
jiffies - call->cjif,
ntohs(call->ackr.maxSkew),
ntohl(call->ackr.firstPacket),
ntohl(call->ackr.previousPacket),
ntohl(call->ackr.serial),
rxrpc_acks[call->ackr.reason],
call->ackr.nAcks);
aux[0] = htonl(call->conn->peer->if_mtu); /* interface MTU */
aux[1] = htonl(1444); /* max MTU */
aux[2] = htonl(16); /* rwind */
aux[3] = htonl(4); /* max packets */
diov[0].iov_len = sizeof(struct rxrpc_ackpacket);
diov[0].iov_base = &call->ackr;
diov[1].iov_len = call->ackr_pend_cnt + 3;
diov[1].iov_base = call->ackr_array;
diov[2].iov_len = sizeof(aux);
diov[2].iov_base = &aux;
/* build and send the message */
ret = rxrpc_conn_newmsg(call->conn,call, RXRPC_PACKET_TYPE_ACK,
3, diov, GFP_KERNEL, &msg);
if (ret < 0)
goto out;
msg->seq = seq;
msg->hdr.seq = htonl(seq);
msg->hdr.flags |= RXRPC_SLOW_START_OK;
ret = rxrpc_conn_sendmsg(call->conn, msg);
rxrpc_put_message(msg);
if (ret < 0)
goto out;
call->pkt_snd_count++;
/* count how many actual ACKs there were at the front */
for (delta = 0; delta < call->ackr_pend_cnt; delta++)
if (call->ackr_array[delta] != RXRPC_ACK_TYPE_ACK)
break;
call->ackr_pend_cnt -= delta; /* all ACK'd to this point */
/* crank the ACK window around */
if (delta == 0) {
/* un-ACK'd window */
}
else if (delta < RXRPC_CALL_ACK_WINDOW_SIZE) {
/* partially ACK'd window
* - shuffle down to avoid losing out-of-sequence packets
*/
call->ackr_win_bot += delta;
call->ackr_win_top += delta;
memmove(&call->ackr_array[0],
&call->ackr_array[delta],
call->ackr_pend_cnt);
memset(&call->ackr_array[call->ackr_pend_cnt],
RXRPC_ACK_TYPE_NACK,
sizeof(call->ackr_array) - call->ackr_pend_cnt);
}
else {
/* fully ACK'd window
* - just clear the whole thing
*/
memset(&call->ackr_array,
RXRPC_ACK_TYPE_NACK,
sizeof(call->ackr_array));
}
/* clear this ACK */
memset(&call->ackr, 0, sizeof(call->ackr));
out:
if (!call->app_call_state)
printk("___ STATE 0 ___\n");
return ret;
} /* end __rxrpc_call_gen_normal_ACK() */
/*****************************************************************************/
/*
* note the reception of a packet in the call's ACK records and generate an
* appropriate ACK packet if necessary
* - returns 0 if packet should be processed, 1 if packet should be ignored
* and -ve on an error
*/
static int rxrpc_call_generate_ACK(struct rxrpc_call *call,
struct rxrpc_header *hdr,
struct rxrpc_ackpacket *ack)
{
struct rxrpc_message *msg;
rxrpc_seq_t seq;
unsigned offset;
int ret = 0, err;
u8 special_ACK, do_ACK, force;
_enter("%p,%p { seq=%d tp=%d fl=%02x }",
call, hdr, ntohl(hdr->seq), hdr->type, hdr->flags);
seq = ntohl(hdr->seq);
offset = seq - call->ackr_win_bot;
do_ACK = RXRPC_ACK_DELAY;
special_ACK = 0;
force = (seq == 1);
if (call->ackr_high_seq < seq)
call->ackr_high_seq = seq;
/* deal with generation of obvious special ACKs first */
if (ack && ack->reason == RXRPC_ACK_PING) {
special_ACK = RXRPC_ACK_PING_RESPONSE;
ret = 1;
goto gen_ACK;
}
if (seq < call->ackr_win_bot) {
special_ACK = RXRPC_ACK_DUPLICATE;
ret = 1;
goto gen_ACK;
}
if (seq >= call->ackr_win_top) {
special_ACK = RXRPC_ACK_EXCEEDS_WINDOW;
ret = 1;
goto gen_ACK;
}
if (call->ackr_array[offset] != RXRPC_ACK_TYPE_NACK) {
special_ACK = RXRPC_ACK_DUPLICATE;
ret = 1;
goto gen_ACK;
}
/* okay... it's a normal data packet inside the ACK window */
call->ackr_array[offset] = RXRPC_ACK_TYPE_ACK;
if (offset < call->ackr_pend_cnt) {
}
else if (offset > call->ackr_pend_cnt) {
do_ACK = RXRPC_ACK_OUT_OF_SEQUENCE;
call->ackr_pend_cnt = offset;
goto gen_ACK;
}
if (hdr->flags & RXRPC_REQUEST_ACK) {
do_ACK = RXRPC_ACK_REQUESTED;
}
/* generate an ACK on the final packet of a reply just received */
if (hdr->flags & RXRPC_LAST_PACKET) {
if (call->conn->out_clientflag)
force = 1;
}
else if (!(hdr->flags & RXRPC_MORE_PACKETS)) {
do_ACK = RXRPC_ACK_REQUESTED;
}
/* re-ACK packets previously received out-of-order */
for (offset++; offset < RXRPC_CALL_ACK_WINDOW_SIZE; offset++)
if (call->ackr_array[offset] != RXRPC_ACK_TYPE_ACK)
break;
call->ackr_pend_cnt = offset;
/* generate an ACK if we fill up the window */
if (call->ackr_pend_cnt >= RXRPC_CALL_ACK_WINDOW_SIZE)
force = 1;
gen_ACK:
_debug("%05lu ACKs pend=%u norm=%s special=%s%s",
jiffies - call->cjif,
call->ackr_pend_cnt,
rxrpc_acks[do_ACK],
rxrpc_acks[special_ACK],
force ? " immediate" :
do_ACK == RXRPC_ACK_REQUESTED ? " merge-req" :
hdr->flags & RXRPC_LAST_PACKET ? " finalise" :
" defer"
);
/* send any pending normal ACKs if need be */
if (call->ackr_pend_cnt > 0) {
/* fill out the appropriate form */
call->ackr.bufferSpace = htons(RXRPC_CALL_ACK_WINDOW_SIZE);
call->ackr.maxSkew = htons(min(call->ackr_high_seq - seq,
65535U));
call->ackr.firstPacket = htonl(call->ackr_win_bot);
call->ackr.previousPacket = call->ackr_prev_seq;
call->ackr.serial = hdr->serial;
call->ackr.nAcks = call->ackr_pend_cnt;
if (do_ACK == RXRPC_ACK_REQUESTED)
call->ackr.reason = do_ACK;
/* generate the ACK immediately if necessary */
if (special_ACK || force) {
err = __rxrpc_call_gen_normal_ACK(
call, do_ACK == RXRPC_ACK_DELAY ? 0 : seq);
if (err < 0) {
ret = err;
goto out;
}
}
}
if (call->ackr.reason == RXRPC_ACK_REQUESTED)
call->ackr_dfr_seq = seq;
/* start the ACK timer if not running if there are any pending deferred
* ACKs */
if (call->ackr_pend_cnt > 0 &&
call->ackr.reason != RXRPC_ACK_REQUESTED &&
!timer_pending(&call->ackr_dfr_timo)
) {
unsigned long timo;
timo = rxrpc_call_dfr_ack_timeout + jiffies;
_debug("START ACKR TIMER for cj=%lu", timo - call->cjif);
spin_lock(&call->lock);
mod_timer(&call->ackr_dfr_timo, timo);
spin_unlock(&call->lock);
}
else if ((call->ackr_pend_cnt == 0 ||
call->ackr.reason == RXRPC_ACK_REQUESTED) &&
timer_pending(&call->ackr_dfr_timo)
) {
/* stop timer if no pending ACKs */
_debug("CLEAR ACKR TIMER");
del_timer_sync(&call->ackr_dfr_timo);
}
/* send a special ACK if one is required */
if (special_ACK) {
struct rxrpc_ackpacket ack;
struct kvec diov[2];
uint8_t acks[1] = { RXRPC_ACK_TYPE_ACK };
/* fill out the appropriate form */
ack.bufferSpace = htons(RXRPC_CALL_ACK_WINDOW_SIZE);
ack.maxSkew = htons(min(call->ackr_high_seq - seq,
65535U));
ack.firstPacket = htonl(call->ackr_win_bot);
ack.previousPacket = call->ackr_prev_seq;
ack.serial = hdr->serial;
ack.reason = special_ACK;
ack.nAcks = 0;
_proto("Rx Sending s-ACK"
" { m=%hu f=#%u p=#%u s=%%%u r=%s n=%u }",
ntohs(ack.maxSkew),
ntohl(ack.firstPacket),
ntohl(ack.previousPacket),
ntohl(ack.serial),
rxrpc_acks[ack.reason],
ack.nAcks);
diov[0].iov_len = sizeof(struct rxrpc_ackpacket);
diov[0].iov_base = &ack;
diov[1].iov_len = sizeof(acks);
diov[1].iov_base = acks;
/* build and send the message */
err = rxrpc_conn_newmsg(call->conn,call, RXRPC_PACKET_TYPE_ACK,
hdr->seq ? 2 : 1, diov,
GFP_KERNEL,
&msg);
if (err < 0) {
ret = err;
goto out;
}
msg->seq = seq;
msg->hdr.seq = htonl(seq);
msg->hdr.flags |= RXRPC_SLOW_START_OK;
err = rxrpc_conn_sendmsg(call->conn, msg);
rxrpc_put_message(msg);
if (err < 0) {
ret = err;
goto out;
}
call->pkt_snd_count++;
}
out:
if (hdr->seq)
call->ackr_prev_seq = hdr->seq;
_leave(" = %d", ret);
return ret;
} /* end rxrpc_call_generate_ACK() */
/*****************************************************************************/
/*
* handle work to be done on a call
* - includes packet reception and timeout processing
*/
void rxrpc_call_do_stuff(struct rxrpc_call *call)
{
_enter("%p{flags=%lx}", call, call->flags);
/* handle packet reception */
if (call->flags & RXRPC_CALL_RCV_PKT) {
_debug("- receive packet");
call->flags &= ~RXRPC_CALL_RCV_PKT;
rxrpc_call_receive_packet(call);
}
/* handle overdue ACKs */
if (call->flags & RXRPC_CALL_ACKS_TIMO) {
_debug("- overdue ACK timeout");
call->flags &= ~RXRPC_CALL_ACKS_TIMO;
rxrpc_call_resend(call, call->snd_seq_count);
}
/* handle lack of reception */
if (call->flags & RXRPC_CALL_RCV_TIMO) {
_debug("- reception timeout");
call->flags &= ~RXRPC_CALL_RCV_TIMO;
rxrpc_call_abort(call, -EIO);
}
/* handle deferred ACKs */
if (call->flags & RXRPC_CALL_ACKR_TIMO ||
(call->ackr.nAcks > 0 && call->ackr.reason == RXRPC_ACK_REQUESTED)
) {
_debug("- deferred ACK timeout: cj=%05lu r=%s n=%u",
jiffies - call->cjif,
rxrpc_acks[call->ackr.reason],
call->ackr.nAcks);
call->flags &= ~RXRPC_CALL_ACKR_TIMO;
if (call->ackr.nAcks > 0 &&
call->app_call_state != RXRPC_CSTATE_ERROR) {
/* generate ACK */
__rxrpc_call_gen_normal_ACK(call, call->ackr_dfr_seq);
call->ackr_dfr_seq = 0;
}
}
_leave("");
} /* end rxrpc_call_do_stuff() */
/*****************************************************************************/
/*
* send an abort message at call or connection level
* - must be called with call->lock held
* - the supplied error code is sent as the packet data
*/
static int __rxrpc_call_abort(struct rxrpc_call *call, int errno)
{
struct rxrpc_connection *conn = call->conn;
struct rxrpc_message *msg;
struct kvec diov[1];
int ret;
__be32 _error;
_enter("%p{%08x},%p{%d},%d",
conn, ntohl(conn->conn_id), call, ntohl(call->call_id), errno);
/* if this call is already aborted, then just wake up any waiters */
if (call->app_call_state == RXRPC_CSTATE_ERROR) {
spin_unlock(&call->lock);
call->app_error_func(call);
_leave(" = 0");
return 0;
}
rxrpc_get_call(call);
/* change the state _with_ the lock still held */
call->app_call_state = RXRPC_CSTATE_ERROR;
call->app_err_state = RXRPC_ESTATE_LOCAL_ABORT;
call->app_errno = errno;
call->app_mark = RXRPC_APP_MARK_EOF;
call->app_read_buf = NULL;
call->app_async_read = 0;
_state(call);
/* ask the app to translate the error code */
call->app_aemap_func(call);
spin_unlock(&call->lock);
/* flush any outstanding ACKs */
del_timer_sync(&call->acks_timeout);
del_timer_sync(&call->rcv_timeout);
del_timer_sync(&call->ackr_dfr_timo);
if (rxrpc_call_is_ack_pending(call))
__rxrpc_call_gen_normal_ACK(call, 0);
/* send the abort packet only if we actually traded some other
* packets */
ret = 0;
if (call->pkt_snd_count || call->pkt_rcv_count) {
/* actually send the abort */
_proto("Rx Sending Call ABORT { data=%d }",
call->app_abort_code);
_error = htonl(call->app_abort_code);
diov[0].iov_len = sizeof(_error);
diov[0].iov_base = &_error;
ret = rxrpc_conn_newmsg(conn, call, RXRPC_PACKET_TYPE_ABORT,
1, diov, GFP_KERNEL, &msg);
if (ret == 0) {
ret = rxrpc_conn_sendmsg(conn, msg);
rxrpc_put_message(msg);
}
}
/* tell the app layer to let go */
call->app_error_func(call);
rxrpc_put_call(call);
_leave(" = %d", ret);
return ret;
} /* end __rxrpc_call_abort() */
/*****************************************************************************/
/*
* send an abort message at call or connection level
* - the supplied error code is sent as the packet data
*/
int rxrpc_call_abort(struct rxrpc_call *call, int error)
{
spin_lock(&call->lock);
return __rxrpc_call_abort(call, error);
} /* end rxrpc_call_abort() */
/*****************************************************************************/
/*
* process packets waiting for this call
*/
static void rxrpc_call_receive_packet(struct rxrpc_call *call)
{
struct rxrpc_message *msg;
struct list_head *_p;
_enter("%p", call);
rxrpc_get_call(call); /* must not go away too soon if aborted by
* app-layer */
while (!list_empty(&call->rcv_receiveq)) {
/* try to get next packet */
_p = NULL;
spin_lock(&call->lock);
if (!list_empty(&call->rcv_receiveq)) {
_p = call->rcv_receiveq.next;
list_del_init(_p);
}
spin_unlock(&call->lock);
if (!_p)
break;
msg = list_entry(_p, struct rxrpc_message, link);
_proto("Rx %05lu Received %s packet (%%%u,#%u,%c%c%c%c%c)",
jiffies - call->cjif,
rxrpc_pkts[msg->hdr.type],
ntohl(msg->hdr.serial),
msg->seq,
msg->hdr.flags & RXRPC_JUMBO_PACKET ? 'j' : '-',
msg->hdr.flags & RXRPC_MORE_PACKETS ? 'm' : '-',
msg->hdr.flags & RXRPC_LAST_PACKET ? 'l' : '-',
msg->hdr.flags & RXRPC_REQUEST_ACK ? 'r' : '-',
msg->hdr.flags & RXRPC_CLIENT_INITIATED ? 'C' : 'S'
);
switch (msg->hdr.type) {
/* deal with data packets */
case RXRPC_PACKET_TYPE_DATA:
/* ACK the packet if necessary */
switch (rxrpc_call_generate_ACK(call, &msg->hdr,
NULL)) {
case 0: /* useful packet */
rxrpc_call_receive_data_packet(call, msg);
break;
case 1: /* duplicate or out-of-window packet */
break;
default:
rxrpc_put_message(msg);
goto out;
}
break;
/* deal with ACK packets */
case RXRPC_PACKET_TYPE_ACK:
rxrpc_call_receive_ack_packet(call, msg);
break;
/* deal with abort packets */
case RXRPC_PACKET_TYPE_ABORT: {
__be32 _dbuf, *dp;
dp = skb_header_pointer(msg->pkt, msg->offset,
sizeof(_dbuf), &_dbuf);
if (dp == NULL)
printk("Rx Received short ABORT packet\n");
_proto("Rx Received Call ABORT { data=%d }",
(dp ? ntohl(*dp) : 0));
spin_lock(&call->lock);
call->app_call_state = RXRPC_CSTATE_ERROR;
call->app_err_state = RXRPC_ESTATE_PEER_ABORT;
call->app_abort_code = (dp ? ntohl(*dp) : 0);
call->app_errno = -ECONNABORTED;
call->app_mark = RXRPC_APP_MARK_EOF;
call->app_read_buf = NULL;
call->app_async_read = 0;
/* ask the app to translate the error code */
call->app_aemap_func(call);
_state(call);
spin_unlock(&call->lock);
call->app_error_func(call);
break;
}
default:
/* deal with other packet types */
_proto("Rx Unsupported packet type %u (#%u)",
msg->hdr.type, msg->seq);
break;
}
rxrpc_put_message(msg);
}
out:
rxrpc_put_call(call);
_leave("");
} /* end rxrpc_call_receive_packet() */
/*****************************************************************************/
/*
* process next data packet
* - as the next data packet arrives:
* - it is queued on app_readyq _if_ it is the next one expected
* (app_ready_seq+1)
* - it is queued on app_unreadyq _if_ it is not the next one expected
* - if a packet placed on app_readyq completely fills a hole leading up to
* the first packet on app_unreadyq, then packets now in sequence are
* tranferred to app_readyq
* - the application layer can only see packets on app_readyq
* (app_ready_qty bytes)
* - the application layer is prodded every time a new packet arrives
*/
static void rxrpc_call_receive_data_packet(struct rxrpc_call *call,
struct rxrpc_message *msg)
{
const struct rxrpc_operation *optbl, *op;
struct rxrpc_message *pmsg;
struct list_head *_p;
int ret, lo, hi, rmtimo;
__be32 opid;
_enter("%p{%u},%p{%u}", call, ntohl(call->call_id), msg, msg->seq);
rxrpc_get_message(msg);
/* add to the unready queue if we'd have to create a hole in the ready
* queue otherwise */
if (msg->seq != call->app_ready_seq + 1) {
_debug("Call add packet %d to unreadyq", msg->seq);
/* insert in seq order */
list_for_each(_p, &call->app_unreadyq) {
pmsg = list_entry(_p, struct rxrpc_message, link);
if (pmsg->seq > msg->seq)
break;
}
list_add_tail(&msg->link, _p);
_leave(" [unreadyq]");
return;
}
/* next in sequence - simply append into the call's ready queue */
_debug("Call add packet %d to readyq (+%Zd => %Zd bytes)",
msg->seq, msg->dsize, call->app_ready_qty);
spin_lock(&call->lock);
call->app_ready_seq = msg->seq;
call->app_ready_qty += msg->dsize;
list_add_tail(&msg->link, &call->app_readyq);
/* move unready packets to the readyq if we got rid of a hole */
while (!list_empty(&call->app_unreadyq)) {
pmsg = list_entry(call->app_unreadyq.next,
struct rxrpc_message, link);
if (pmsg->seq != call->app_ready_seq + 1)
break;
/* next in sequence - just move list-to-list */
_debug("Call transfer packet %d to readyq (+%Zd => %Zd bytes)",
pmsg->seq, pmsg->dsize, call->app_ready_qty);
call->app_ready_seq = pmsg->seq;
call->app_ready_qty += pmsg->dsize;
list_move_tail(&pmsg->link, &call->app_readyq);
}
/* see if we've got the last packet yet */
if (!list_empty(&call->app_readyq)) {
pmsg = list_entry(call->app_readyq.prev,
struct rxrpc_message, link);
if (pmsg->hdr.flags & RXRPC_LAST_PACKET) {
call->app_last_rcv = 1;
_debug("Last packet on readyq");
}
}
switch (call->app_call_state) {
/* do nothing if call already aborted */
case RXRPC_CSTATE_ERROR:
spin_unlock(&call->lock);
_leave(" [error]");
return;
/* extract the operation ID from an incoming call if that's not
* yet been done */
case RXRPC_CSTATE_SRVR_RCV_OPID:
spin_unlock(&call->lock);
/* handle as yet insufficient data for the operation ID */
if (call->app_ready_qty < 4) {
if (call->app_last_rcv)
/* trouble - last packet seen */
rxrpc_call_abort(call, -EINVAL);
_leave("");
return;
}
/* pull the operation ID out of the buffer */
ret = rxrpc_call_read_data(call, &opid, sizeof(opid), 0);
if (ret < 0) {
printk("Unexpected error from read-data: %d\n", ret);
if (call->app_call_state != RXRPC_CSTATE_ERROR)
rxrpc_call_abort(call, ret);
_leave("");
return;
}
call->app_opcode = ntohl(opid);
/* locate the operation in the available ops table */
optbl = call->conn->service->ops_begin;
lo = 0;
hi = call->conn->service->ops_end - optbl;
while (lo < hi) {
int mid = (hi + lo) / 2;
op = &optbl[mid];
if (call->app_opcode == op->id)
goto found_op;
if (call->app_opcode > op->id)
lo = mid + 1;
else
hi = mid;
}
/* search failed */
kproto("Rx Client requested operation %d from %s service",
call->app_opcode, call->conn->service->name);
rxrpc_call_abort(call, -EINVAL);
_leave(" [inval]");
return;
found_op:
_proto("Rx Client requested operation %s from %s service",
op->name, call->conn->service->name);
/* we're now waiting for the argument block (unless the call
* was aborted) */
spin_lock(&call->lock);
if (call->app_call_state == RXRPC_CSTATE_SRVR_RCV_OPID ||
call->app_call_state == RXRPC_CSTATE_SRVR_SND_REPLY) {
if (!call->app_last_rcv)
call->app_call_state =
RXRPC_CSTATE_SRVR_RCV_ARGS;
else if (call->app_ready_qty > 0)
call->app_call_state =
RXRPC_CSTATE_SRVR_GOT_ARGS;
else
call->app_call_state =
RXRPC_CSTATE_SRVR_SND_REPLY;
call->app_mark = op->asize;
call->app_user = op->user;
}
spin_unlock(&call->lock);
_state(call);
break;
case RXRPC_CSTATE_SRVR_RCV_ARGS:
/* change state if just received last packet of arg block */
if (call->app_last_rcv)
call->app_call_state = RXRPC_CSTATE_SRVR_GOT_ARGS;
spin_unlock(&call->lock);
_state(call);
break;
case RXRPC_CSTATE_CLNT_RCV_REPLY:
/* change state if just received last packet of reply block */
rmtimo = 0;
if (call->app_last_rcv) {
call->app_call_state = RXRPC_CSTATE_CLNT_GOT_REPLY;
rmtimo = 1;
}
spin_unlock(&call->lock);
if (rmtimo) {
del_timer_sync(&call->acks_timeout);
del_timer_sync(&call->rcv_timeout);
del_timer_sync(&call->ackr_dfr_timo);
}
_state(call);
break;
default:
/* deal with data reception in an unexpected state */
printk("Unexpected state [[[ %u ]]]\n", call->app_call_state);
__rxrpc_call_abort(call, -EBADMSG);
_leave("");
return;
}
if (call->app_call_state == RXRPC_CSTATE_CLNT_RCV_REPLY &&
call->app_last_rcv)
BUG();
/* otherwise just invoke the data function whenever we can satisfy its desire for more
* data
*/
_proto("Rx Received Op Data: st=%u qty=%Zu mk=%Zu%s",
call->app_call_state, call->app_ready_qty, call->app_mark,
call->app_last_rcv ? " last-rcvd" : "");
spin_lock(&call->lock);
ret = __rxrpc_call_read_data(call);
switch (ret) {
case 0:
spin_unlock(&call->lock);
call->app_attn_func(call);
break;
case -EAGAIN:
spin_unlock(&call->lock);
break;
case -ECONNABORTED:
spin_unlock(&call->lock);
break;
default:
__rxrpc_call_abort(call, ret);
break;
}
_state(call);
_leave("");
} /* end rxrpc_call_receive_data_packet() */
/*****************************************************************************/
/*
* received an ACK packet
*/
static void rxrpc_call_receive_ack_packet(struct rxrpc_call *call,
struct rxrpc_message *msg)
{
struct rxrpc_ackpacket _ack, *ap;
rxrpc_serial_net_t serial;
rxrpc_seq_t seq;
int ret;
_enter("%p{%u},%p{%u}", call, ntohl(call->call_id), msg, msg->seq);
/* extract the basic ACK record */
ap = skb_header_pointer(msg->pkt, msg->offset, sizeof(_ack), &_ack);
if (ap == NULL) {
printk("Rx Received short ACK packet\n");
return;
}
msg->offset += sizeof(_ack);
serial = ap->serial;
seq = ntohl(ap->firstPacket);
_proto("Rx Received ACK %%%d { b=%hu m=%hu f=%u p=%u s=%u r=%s n=%u }",
ntohl(msg->hdr.serial),
ntohs(ap->bufferSpace),
ntohs(ap->maxSkew),
seq,
ntohl(ap->previousPacket),
ntohl(serial),
rxrpc_acks[ap->reason],
call->ackr.nAcks
);
/* check the other side isn't ACK'ing a sequence number I haven't sent
* yet */
if (ap->nAcks > 0 &&
(seq > call->snd_seq_count ||
seq + ap->nAcks - 1 > call->snd_seq_count)) {
printk("Received ACK (#%u-#%u) for unsent packet\n",
seq, seq + ap->nAcks - 1);
rxrpc_call_abort(call, -EINVAL);
_leave("");
return;
}
/* deal with RTT calculation */
if (serial) {
struct rxrpc_message *rttmsg;
/* find the prompting packet */
spin_lock(&call->lock);
if (call->snd_ping && call->snd_ping->hdr.serial == serial) {
/* it was a ping packet */
rttmsg = call->snd_ping;
call->snd_ping = NULL;
spin_unlock(&call->lock);
if (rttmsg) {
rttmsg->rttdone = 1;
rxrpc_peer_calculate_rtt(call->conn->peer,
rttmsg, msg);
rxrpc_put_message(rttmsg);
}
}
else {
struct list_head *_p;
/* it ought to be a data packet - look in the pending
* ACK list */
list_for_each(_p, &call->acks_pendq) {
rttmsg = list_entry(_p, struct rxrpc_message,
link);
if (rttmsg->hdr.serial == serial) {
if (rttmsg->rttdone)
/* never do RTT twice without
* resending */
break;
rttmsg->rttdone = 1;
rxrpc_peer_calculate_rtt(
call->conn->peer, rttmsg, msg);
break;
}
}
spin_unlock(&call->lock);
}
}
switch (ap->reason) {
/* deal with negative/positive acknowledgement of data
* packets */
case RXRPC_ACK_REQUESTED:
case RXRPC_ACK_DELAY:
case RXRPC_ACK_IDLE:
rxrpc_call_definitively_ACK(call, seq - 1);
case RXRPC_ACK_DUPLICATE:
case RXRPC_ACK_OUT_OF_SEQUENCE:
case RXRPC_ACK_EXCEEDS_WINDOW:
call->snd_resend_cnt = 0;
ret = rxrpc_call_record_ACK(call, msg, seq, ap->nAcks);
if (ret < 0)
rxrpc_call_abort(call, ret);
break;
/* respond to ping packets immediately */
case RXRPC_ACK_PING:
rxrpc_call_generate_ACK(call, &msg->hdr, ap);
break;
/* only record RTT on ping response packets */
case RXRPC_ACK_PING_RESPONSE:
if (call->snd_ping) {
struct rxrpc_message *rttmsg;
/* only do RTT stuff if the response matches the
* retained ping */
rttmsg = NULL;
spin_lock(&call->lock);
if (call->snd_ping &&
call->snd_ping->hdr.serial == ap->serial) {
rttmsg = call->snd_ping;
call->snd_ping = NULL;
}
spin_unlock(&call->lock);
if (rttmsg) {
rttmsg->rttdone = 1;
rxrpc_peer_calculate_rtt(call->conn->peer,
rttmsg, msg);
rxrpc_put_message(rttmsg);
}
}
break;
default:
printk("Unsupported ACK reason %u\n", ap->reason);
break;
}
_leave("");
} /* end rxrpc_call_receive_ack_packet() */
/*****************************************************************************/
/*
* record definitive ACKs for all messages up to and including the one with the
* 'highest' seq
*/
static void rxrpc_call_definitively_ACK(struct rxrpc_call *call,
rxrpc_seq_t highest)
{
struct rxrpc_message *msg;
int now_complete;
_enter("%p{ads=%u},%u", call, call->acks_dftv_seq, highest);
while (call->acks_dftv_seq < highest) {
call->acks_dftv_seq++;
_proto("Definitive ACK on packet #%u", call->acks_dftv_seq);
/* discard those at front of queue until message with highest
* ACK is found */
spin_lock(&call->lock);
msg = NULL;
if (!list_empty(&call->acks_pendq)) {
msg = list_entry(call->acks_pendq.next,
struct rxrpc_message, link);
list_del_init(&msg->link); /* dequeue */
if (msg->state == RXRPC_MSG_SENT)
call->acks_pend_cnt--;
}
spin_unlock(&call->lock);
/* insanity check */
if (!msg)
panic("%s(): acks_pendq unexpectedly empty\n",
__FUNCTION__);
if (msg->seq != call->acks_dftv_seq)
panic("%s(): Packet #%u expected at front of acks_pendq"
" (#%u found)\n",
__FUNCTION__, call->acks_dftv_seq, msg->seq);
/* discard the message */
msg->state = RXRPC_MSG_DONE;
rxrpc_put_message(msg);
}
/* if all sent packets are definitively ACK'd then prod any sleepers just in case */
now_complete = 0;
spin_lock(&call->lock);
if (call->acks_dftv_seq == call->snd_seq_count) {
if (call->app_call_state != RXRPC_CSTATE_COMPLETE) {
call->app_call_state = RXRPC_CSTATE_COMPLETE;
_state(call);
now_complete = 1;
}
}
spin_unlock(&call->lock);
if (now_complete) {
del_timer_sync(&call->acks_timeout);
del_timer_sync(&call->rcv_timeout);
del_timer_sync(&call->ackr_dfr_timo);
call->app_attn_func(call);
}
_leave("");
} /* end rxrpc_call_definitively_ACK() */
/*****************************************************************************/
/*
* record the specified amount of ACKs/NAKs
*/
static int rxrpc_call_record_ACK(struct rxrpc_call *call,
struct rxrpc_message *msg,
rxrpc_seq_t seq,
size_t count)
{
struct rxrpc_message *dmsg;
struct list_head *_p;
rxrpc_seq_t highest;
unsigned ix;
size_t chunk;
char resend, now_complete;
u8 acks[16];
_enter("%p{apc=%u ads=%u},%p,%u,%Zu",
call, call->acks_pend_cnt, call->acks_dftv_seq,
msg, seq, count);
/* handle re-ACK'ing of definitively ACK'd packets (may be out-of-order
* ACKs) */
if (seq <= call->acks_dftv_seq) {
unsigned delta = call->acks_dftv_seq - seq;
if (count <= delta) {
_leave(" = 0 [all definitively ACK'd]");
return 0;
}
seq += delta;
count -= delta;
msg->offset += delta;
}
highest = seq + count - 1;
resend = 0;
while (count > 0) {
/* extract up to 16 ACK slots at a time */
chunk = min(count, sizeof(acks));
count -= chunk;
memset(acks, 2, sizeof(acks));
if (skb_copy_bits(msg->pkt, msg->offset, &acks, chunk) < 0) {
printk("Rx Received short ACK packet\n");
_leave(" = -EINVAL");
return -EINVAL;
}
msg->offset += chunk;
/* check that the ACK set is valid */
for (ix = 0; ix < chunk; ix++) {
switch (acks[ix]) {
case RXRPC_ACK_TYPE_ACK:
break;
case RXRPC_ACK_TYPE_NACK:
resend = 1;
break;
default:
printk("Rx Received unsupported ACK state"
" %u\n", acks[ix]);
_leave(" = -EINVAL");
return -EINVAL;
}
}
_proto("Rx ACK of packets #%u-#%u "
"[%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c] (pend=%u)",
seq, (unsigned) (seq + chunk - 1),
_acktype[acks[0x0]],
_acktype[acks[0x1]],
_acktype[acks[0x2]],
_acktype[acks[0x3]],
_acktype[acks[0x4]],
_acktype[acks[0x5]],
_acktype[acks[0x6]],
_acktype[acks[0x7]],
_acktype[acks[0x8]],
_acktype[acks[0x9]],
_acktype[acks[0xA]],
_acktype[acks[0xB]],
_acktype[acks[0xC]],
_acktype[acks[0xD]],
_acktype[acks[0xE]],
_acktype[acks[0xF]],
call->acks_pend_cnt
);
/* mark the packets in the ACK queue as being provisionally
* ACK'd */
ix = 0;
spin_lock(&call->lock);
/* find the first packet ACK'd/NAK'd here */
list_for_each(_p, &call->acks_pendq) {
dmsg = list_entry(_p, struct rxrpc_message, link);
if (dmsg->seq == seq)
goto found_first;
_debug("- %u: skipping #%u", ix, dmsg->seq);
}
goto bad_queue;
found_first:
do {
_debug("- %u: processing #%u (%c) apc=%u",
ix, dmsg->seq, _acktype[acks[ix]],
call->acks_pend_cnt);
if (acks[ix] == RXRPC_ACK_TYPE_ACK) {
if (dmsg->state == RXRPC_MSG_SENT)
call->acks_pend_cnt--;
dmsg->state = RXRPC_MSG_ACKED;
}
else {
if (dmsg->state == RXRPC_MSG_ACKED)
call->acks_pend_cnt++;
dmsg->state = RXRPC_MSG_SENT;
}
ix++;
seq++;
_p = dmsg->link.next;
dmsg = list_entry(_p, struct rxrpc_message, link);
} while(ix < chunk &&
_p != &call->acks_pendq &&
dmsg->seq == seq);
if (ix < chunk)
goto bad_queue;
spin_unlock(&call->lock);
}
if (resend)
rxrpc_call_resend(call, highest);
/* if all packets are provisionally ACK'd, then wake up anyone who's
* waiting for that */
now_complete = 0;
spin_lock(&call->lock);
if (call->acks_pend_cnt == 0) {
if (call->app_call_state == RXRPC_CSTATE_SRVR_RCV_FINAL_ACK) {
call->app_call_state = RXRPC_CSTATE_COMPLETE;
_state(call);
}
now_complete = 1;
}
spin_unlock(&call->lock);
if (now_complete) {
_debug("- wake up waiters");
del_timer_sync(&call->acks_timeout);
del_timer_sync(&call->rcv_timeout);
del_timer_sync(&call->ackr_dfr_timo);
call->app_attn_func(call);
}
_leave(" = 0 (apc=%u)", call->acks_pend_cnt);
return 0;
bad_queue:
panic("%s(): acks_pendq in bad state (packet #%u absent)\n",
__FUNCTION__, seq);
} /* end rxrpc_call_record_ACK() */
/*****************************************************************************/
/*
* transfer data from the ready packet queue to the asynchronous read buffer
* - since this func is the only one going to look at packets queued on
* app_readyq, we don't need a lock to modify or access them, only to modify
* the queue pointers
* - called with call->lock held
* - the buffer must be in kernel space
* - returns:
* 0 if buffer filled
* -EAGAIN if buffer not filled and more data to come
* -EBADMSG if last packet received and insufficient data left
* -ECONNABORTED if the call has in an error state
*/
static int __rxrpc_call_read_data(struct rxrpc_call *call)
{
struct rxrpc_message *msg;
size_t qty;
int ret;
_enter("%p{as=%d buf=%p qty=%Zu/%Zu}",
call,
call->app_async_read, call->app_read_buf,
call->app_ready_qty, call->app_mark);
/* check the state */
switch (call->app_call_state) {
case RXRPC_CSTATE_SRVR_RCV_ARGS:
case RXRPC_CSTATE_CLNT_RCV_REPLY:
if (call->app_last_rcv) {
printk("%s(%p,%p,%Zd):"
" Inconsistent call state (%s, last pkt)",
__FUNCTION__,
call, call->app_read_buf, call->app_mark,
rxrpc_call_states[call->app_call_state]);
BUG();
}
break;
case RXRPC_CSTATE_SRVR_RCV_OPID:
case RXRPC_CSTATE_SRVR_GOT_ARGS:
case RXRPC_CSTATE_CLNT_GOT_REPLY:
break;
case RXRPC_CSTATE_SRVR_SND_REPLY:
if (!call->app_last_rcv) {
printk("%s(%p,%p,%Zd):"
" Inconsistent call state (%s, not last pkt)",
__FUNCTION__,
call, call->app_read_buf, call->app_mark,
rxrpc_call_states[call->app_call_state]);
BUG();
}
_debug("Trying to read data from call in SND_REPLY state");
break;
case RXRPC_CSTATE_ERROR:
_leave(" = -ECONNABORTED");
return -ECONNABORTED;
default:
printk("reading in unexpected state [[[ %u ]]]\n",
call->app_call_state);
BUG();
}
/* handle the case of not having an async buffer */
if (!call->app_async_read) {
if (call->app_mark == RXRPC_APP_MARK_EOF) {
ret = call->app_last_rcv ? 0 : -EAGAIN;
}
else {
if (call->app_mark >= call->app_ready_qty) {
call->app_mark = RXRPC_APP_MARK_EOF;
ret = 0;
}
else {
ret = call->app_last_rcv ? -EBADMSG : -EAGAIN;
}
}
_leave(" = %d [no buf]", ret);
return 0;
}
while (!list_empty(&call->app_readyq) && call->app_mark > 0) {
msg = list_entry(call->app_readyq.next,
struct rxrpc_message, link);
/* drag as much data as we need out of this packet */
qty = min(call->app_mark, msg->dsize);
_debug("reading %Zu from skb=%p off=%lu",
qty, msg->pkt, msg->offset);
if (call->app_read_buf)
if (skb_copy_bits(msg->pkt, msg->offset,
call->app_read_buf, qty) < 0)
panic("%s: Failed to copy data from packet:"
" (%p,%p,%Zd)",
__FUNCTION__,
call, call->app_read_buf, qty);
/* if that packet is now empty, discard it */
call->app_ready_qty -= qty;
msg->dsize -= qty;
if (msg->dsize == 0) {
list_del_init(&msg->link);
rxrpc_put_message(msg);
}
else {
msg->offset += qty;
}
call->app_mark -= qty;
if (call->app_read_buf)
call->app_read_buf += qty;
}
if (call->app_mark == 0) {
call->app_async_read = 0;
call->app_mark = RXRPC_APP_MARK_EOF;
call->app_read_buf = NULL;
/* adjust the state if used up all packets */
if (list_empty(&call->app_readyq) && call->app_last_rcv) {
switch (call->app_call_state) {
case RXRPC_CSTATE_SRVR_RCV_OPID:
call->app_call_state = RXRPC_CSTATE_SRVR_SND_REPLY;
call->app_mark = RXRPC_APP_MARK_EOF;
_state(call);
del_timer_sync(&call->rcv_timeout);
break;
case RXRPC_CSTATE_SRVR_GOT_ARGS:
call->app_call_state = RXRPC_CSTATE_SRVR_SND_REPLY;
_state(call);
del_timer_sync(&call->rcv_timeout);
break;
default:
call->app_call_state = RXRPC_CSTATE_COMPLETE;
_state(call);
del_timer_sync(&call->acks_timeout);
del_timer_sync(&call->ackr_dfr_timo);
del_timer_sync(&call->rcv_timeout);
break;
}
}
_leave(" = 0");
return 0;
}
if (call->app_last_rcv) {
_debug("Insufficient data (%Zu/%Zu)",
call->app_ready_qty, call->app_mark);
call->app_async_read = 0;
call->app_mark = RXRPC_APP_MARK_EOF;
call->app_read_buf = NULL;
_leave(" = -EBADMSG");
return -EBADMSG;
}
_leave(" = -EAGAIN");
return -EAGAIN;
} /* end __rxrpc_call_read_data() */
/*****************************************************************************/
/*
* attempt to read the specified amount of data from the call's ready queue
* into the buffer provided
* - since this func is the only one going to look at packets queued on
* app_readyq, we don't need a lock to modify or access them, only to modify
* the queue pointers
* - if the buffer pointer is NULL, then data is merely drained, not copied
* - if flags&RXRPC_CALL_READ_BLOCK, then the function will wait until there is
* enough data or an error will be generated
* - note that the caller must have added the calling task to the call's wait
* queue beforehand
* - if flags&RXRPC_CALL_READ_ALL, then an error will be generated if this
* function doesn't read all available data
*/
int rxrpc_call_read_data(struct rxrpc_call *call,
void *buffer, size_t size, int flags)
{
int ret;
_enter("%p{arq=%Zu},%p,%Zd,%x",
call, call->app_ready_qty, buffer, size, flags);
spin_lock(&call->lock);
if (unlikely(!!call->app_read_buf)) {
spin_unlock(&call->lock);
_leave(" = -EBUSY");
return -EBUSY;
}
call->app_mark = size;
call->app_read_buf = buffer;
call->app_async_read = 1;
call->app_read_count++;
/* read as much data as possible */
ret = __rxrpc_call_read_data(call);
switch (ret) {
case 0:
if (flags & RXRPC_CALL_READ_ALL &&
(!call->app_last_rcv || call->app_ready_qty > 0)) {
_leave(" = -EBADMSG");
__rxrpc_call_abort(call, -EBADMSG);
return -EBADMSG;
}
spin_unlock(&call->lock);
call->app_attn_func(call);
_leave(" = 0");
return ret;
case -ECONNABORTED:
spin_unlock(&call->lock);
_leave(" = %d [aborted]", ret);
return ret;
default:
__rxrpc_call_abort(call, ret);
_leave(" = %d", ret);
return ret;
case -EAGAIN:
spin_unlock(&call->lock);
if (!(flags & RXRPC_CALL_READ_BLOCK)) {
_leave(" = -EAGAIN");
return -EAGAIN;
}
/* wait for the data to arrive */
_debug("blocking for data arrival");
for (;;) {
set_current_state(TASK_INTERRUPTIBLE);
if (!call->app_async_read || signal_pending(current))
break;
schedule();
}
set_current_state(TASK_RUNNING);
if (signal_pending(current)) {
_leave(" = -EINTR");
return -EINTR;
}
if (call->app_call_state == RXRPC_CSTATE_ERROR) {
_leave(" = -ECONNABORTED");
return -ECONNABORTED;
}
_leave(" = 0");
return 0;
}
} /* end rxrpc_call_read_data() */
/*****************************************************************************/
/*
* write data to a call
* - the data may not be sent immediately if it doesn't fill a buffer
* - if we can't queue all the data for buffering now, siov[] will have been
* adjusted to take account of what has been sent
*/
int rxrpc_call_write_data(struct rxrpc_call *call,
size_t sioc,
struct kvec *siov,
u8 rxhdr_flags,
gfp_t alloc_flags,
int dup_data,
size_t *size_sent)
{
struct rxrpc_message *msg;
struct kvec *sptr;
size_t space, size, chunk, tmp;
char *buf;
int ret;
_enter("%p,%Zu,%p,%02x,%x,%d,%p",
call, sioc, siov, rxhdr_flags, alloc_flags, dup_data,
size_sent);
*size_sent = 0;
size = 0;
ret = -EINVAL;
/* can't send more if we've sent last packet from this end */
switch (call->app_call_state) {
case RXRPC_CSTATE_SRVR_SND_REPLY:
case RXRPC_CSTATE_CLNT_SND_ARGS:
break;
case RXRPC_CSTATE_ERROR:
ret = call->app_errno;
default:
goto out;
}
/* calculate how much data we've been given */
sptr = siov;
for (; sioc > 0; sptr++, sioc--) {
if (!sptr->iov_len)
continue;
if (!sptr->iov_base)
goto out;
size += sptr->iov_len;
}
_debug("- size=%Zu mtu=%Zu", size, call->conn->mtu_size);
do {
/* make sure there's a message under construction */
if (!call->snd_nextmsg) {
/* no - allocate a message with no data yet attached */
ret = rxrpc_conn_newmsg(call->conn, call,
RXRPC_PACKET_TYPE_DATA,
0, NULL, alloc_flags,
&call->snd_nextmsg);
if (ret < 0)
goto out;
_debug("- allocated new message [ds=%Zu]",
call->snd_nextmsg->dsize);
}
msg = call->snd_nextmsg;
msg->hdr.flags |= rxhdr_flags;
/* deal with zero-length terminal packet */
if (size == 0) {
if (rxhdr_flags & RXRPC_LAST_PACKET) {
ret = rxrpc_call_flush(call);
if (ret < 0)
goto out;
}
break;
}
/* work out how much space current packet has available */
space = call->conn->mtu_size - msg->dsize;
chunk = min(space, size);
_debug("- [before] space=%Zu chunk=%Zu", space, chunk);
while (!siov->iov_len)
siov++;
/* if we are going to have to duplicate the data then coalesce
* it too */
if (dup_data) {
/* don't allocate more that 1 page at a time */
if (chunk > PAGE_SIZE)
chunk = PAGE_SIZE;
/* allocate a data buffer and attach to the message */
buf = kmalloc(chunk, alloc_flags);
if (unlikely(!buf)) {
if (msg->dsize ==
sizeof(struct rxrpc_header)) {
/* discard an empty msg and wind back
* the seq counter */
rxrpc_put_message(msg);
call->snd_nextmsg = NULL;
call->snd_seq_count--;
}
ret = -ENOMEM;
goto out;
}
tmp = msg->dcount++;
set_bit(tmp, &msg->dfree);
msg->data[tmp].iov_base = buf;
msg->data[tmp].iov_len = chunk;
msg->dsize += chunk;
*size_sent += chunk;
size -= chunk;
/* load the buffer with data */
while (chunk > 0) {
tmp = min(chunk, siov->iov_len);
memcpy(buf, siov->iov_base, tmp);
buf += tmp;
siov->iov_base += tmp;
siov->iov_len -= tmp;
if (!siov->iov_len)
siov++;
chunk -= tmp;
}
}
else {
/* we want to attach the supplied buffers directly */
while (chunk > 0 &&
msg->dcount < RXRPC_MSG_MAX_IOCS) {
tmp = msg->dcount++;
msg->data[tmp].iov_base = siov->iov_base;
msg->data[tmp].iov_len = siov->iov_len;
msg->dsize += siov->iov_len;
*size_sent += siov->iov_len;
size -= siov->iov_len;
chunk -= siov->iov_len;
siov++;
}
}
_debug("- [loaded] chunk=%Zu size=%Zu", chunk, size);
/* dispatch the message when full, final or requesting ACK */
if (msg->dsize >= call->conn->mtu_size || rxhdr_flags) {
ret = rxrpc_call_flush(call);
if (ret < 0)
goto out;
}
} while(size > 0);
ret = 0;
out:
_leave(" = %d (%Zd queued, %Zd rem)", ret, *size_sent, size);
return ret;
} /* end rxrpc_call_write_data() */
/*****************************************************************************/
/*
* flush outstanding packets to the network
*/
static int rxrpc_call_flush(struct rxrpc_call *call)
{
struct rxrpc_message *msg;
int ret = 0;
_enter("%p", call);
rxrpc_get_call(call);
/* if there's a packet under construction, then dispatch it now */
if (call->snd_nextmsg) {
msg = call->snd_nextmsg;
call->snd_nextmsg = NULL;
if (msg->hdr.flags & RXRPC_LAST_PACKET) {
msg->hdr.flags &= ~RXRPC_MORE_PACKETS;
if (call->app_call_state != RXRPC_CSTATE_CLNT_SND_ARGS)
msg->hdr.flags |= RXRPC_REQUEST_ACK;
}
else {
msg->hdr.flags |= RXRPC_MORE_PACKETS;
}
_proto("Sending DATA message { ds=%Zu dc=%u df=%02lu }",
msg->dsize, msg->dcount, msg->dfree);
/* queue and adjust call state */
spin_lock(&call->lock);
list_add_tail(&msg->link, &call->acks_pendq);
/* decide what to do depending on current state and if this is
* the last packet */
ret = -EINVAL;
switch (call->app_call_state) {
case RXRPC_CSTATE_SRVR_SND_REPLY:
if (msg->hdr.flags & RXRPC_LAST_PACKET) {
call->app_call_state =
RXRPC_CSTATE_SRVR_RCV_FINAL_ACK;
_state(call);
}
break;
case RXRPC_CSTATE_CLNT_SND_ARGS:
if (msg->hdr.flags & RXRPC_LAST_PACKET) {
call->app_call_state =
RXRPC_CSTATE_CLNT_RCV_REPLY;
_state(call);
}
break;
case RXRPC_CSTATE_ERROR:
ret = call->app_errno;
default:
spin_unlock(&call->lock);
goto out;
}
call->acks_pend_cnt++;
mod_timer(&call->acks_timeout,
__rxrpc_rtt_based_timeout(call,
rxrpc_call_acks_timeout));
spin_unlock(&call->lock);
ret = rxrpc_conn_sendmsg(call->conn, msg);
if (ret == 0)
call->pkt_snd_count++;
}
out:
rxrpc_put_call(call);
_leave(" = %d", ret);
return ret;
} /* end rxrpc_call_flush() */
/*****************************************************************************/
/*
* resend NAK'd or unacknowledged packets up to the highest one specified
*/
static void rxrpc_call_resend(struct rxrpc_call *call, rxrpc_seq_t highest)
{
struct rxrpc_message *msg;
struct list_head *_p;
rxrpc_seq_t seq = 0;
_enter("%p,%u", call, highest);
_proto("Rx Resend required");
/* handle too many resends */
if (call->snd_resend_cnt >= rxrpc_call_max_resend) {
_debug("Aborting due to too many resends (rcv=%d)",
call->pkt_rcv_count);
rxrpc_call_abort(call,
call->pkt_rcv_count > 0 ? -EIO : -ETIMEDOUT);
_leave("");
return;
}
spin_lock(&call->lock);
call->snd_resend_cnt++;
for (;;) {
/* determine which the next packet we might need to ACK is */
if (seq <= call->acks_dftv_seq)
seq = call->acks_dftv_seq;
seq++;
if (seq > highest)
break;
/* look for the packet in the pending-ACK queue */
list_for_each(_p, &call->acks_pendq) {
msg = list_entry(_p, struct rxrpc_message, link);
if (msg->seq == seq)
goto found_msg;
}
panic("%s(%p,%d):"
" Inconsistent pending-ACK queue (ds=%u sc=%u sq=%u)\n",
__FUNCTION__, call, highest,
call->acks_dftv_seq, call->snd_seq_count, seq);
found_msg:
if (msg->state != RXRPC_MSG_SENT)
continue; /* only un-ACK'd packets */
rxrpc_get_message(msg);
spin_unlock(&call->lock);
/* send each message again (and ignore any errors we might
* incur) */
_proto("Resending DATA message { ds=%Zu dc=%u df=%02lu }",
msg->dsize, msg->dcount, msg->dfree);
if (rxrpc_conn_sendmsg(call->conn, msg) == 0)
call->pkt_snd_count++;
rxrpc_put_message(msg);
spin_lock(&call->lock);
}
/* reset the timeout */
mod_timer(&call->acks_timeout,
__rxrpc_rtt_based_timeout(call, rxrpc_call_acks_timeout));
spin_unlock(&call->lock);
_leave("");
} /* end rxrpc_call_resend() */
/*****************************************************************************/
/*
* handle an ICMP error being applied to a call
*/
void rxrpc_call_handle_error(struct rxrpc_call *call, int local, int errno)
{
_enter("%p{%u},%d", call, ntohl(call->call_id), errno);
/* if this call is already aborted, then just wake up any waiters */
if (call->app_call_state == RXRPC_CSTATE_ERROR) {
call->app_error_func(call);
}
else {
/* tell the app layer what happened */
spin_lock(&call->lock);
call->app_call_state = RXRPC_CSTATE_ERROR;
_state(call);
if (local)
call->app_err_state = RXRPC_ESTATE_LOCAL_ERROR;
else
call->app_err_state = RXRPC_ESTATE_REMOTE_ERROR;
call->app_errno = errno;
call->app_mark = RXRPC_APP_MARK_EOF;
call->app_read_buf = NULL;
call->app_async_read = 0;
/* map the error */
call->app_aemap_func(call);
del_timer_sync(&call->acks_timeout);
del_timer_sync(&call->rcv_timeout);
del_timer_sync(&call->ackr_dfr_timo);
spin_unlock(&call->lock);
call->app_error_func(call);
}
_leave("");
} /* end rxrpc_call_handle_error() */
Reference in New Issue View Git Blame Copy Permalink