mirrors
/
linux-stable
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
1
0
Fork 0
Code Issues Releases Wiki Activity

tipc: use generic SKB list APIs to manage link transmission queue 

Use standard SKB list APIs associated with struct sk_buff_head to
manage link transmission queue, having relevant code more clean.

Signed-off-by: Ying Xue <ying.xue@windriver.com>
Reviewed-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Ying Xue 2014-11-26 11:41:52 +08:00 committed by David S. Miller
parent 58d78b328a
commit 58dc55f256
5 changed files with 153 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
net/tipc/bcast.c
View File

@ -217,12 +217,13 @@ struct tipc_node *tipc_bclink_retransmit_to(void)
*/ */
static void bclink_retransmit_pkt(u32 after, u32 to) static void bclink_retransmit_pkt(u32 after, u32 to)
{ {
struct sk_buff *buf; struct sk_buff *skb;
buf = bcl->first_out; skb_queue_walk(&bcl->outqueue, skb) {
while (buf && less_eq(buf_seqno(buf), after)) if (more(buf_seqno(skb), after))
buf = buf->next; break;
tipc_link_retransmit(bcl, buf, mod(to - after)); }
tipc_link_retransmit(bcl, skb, mod(to - after));
} }
/** /**
@ -245,14 +246,14 @@ void tipc_bclink_wakeup_users(void)
*/ */
void tipc_bclink_acknowledge(struct tipc_node *n_ptr, u32 acked) void tipc_bclink_acknowledge(struct tipc_node *n_ptr, u32 acked)
{ {
struct sk_buff *crs; struct sk_buff *skb, *tmp;
struct sk_buff *next; struct sk_buff *next;
unsigned int released = 0; unsigned int released = 0;
tipc_bclink_lock(); tipc_bclink_lock();
/* Bail out if tx queue is empty (no clean up is required) */ /* Bail out if tx queue is empty (no clean up is required) */
crs = bcl->first_out; skb = skb_peek(&bcl->outqueue);
if (!crs) if (!skb)
goto exit; goto exit;
/* Determine which messages need to be acknowledged */ /* Determine which messages need to be acknowledged */
@ -271,41 +272,41 @@ void tipc_bclink_acknowledge(struct tipc_node *n_ptr, u32 acked)
* Bail out if specified sequence number does not correspond * Bail out if specified sequence number does not correspond
* to a message that has been sent and not yet acknowledged * to a message that has been sent and not yet acknowledged
*/ */
if (less(acked, buf_seqno(crs)) || if (less(acked, buf_seqno(skb)) ||
less(bcl->fsm_msg_cnt, acked) || less(bcl->fsm_msg_cnt, acked) ||
less_eq(acked, n_ptr->bclink.acked)) less_eq(acked, n_ptr->bclink.acked))
goto exit; goto exit;
} }
/* Skip over packets that node has previously acknowledged */ /* Skip over packets that node has previously acknowledged */
while (crs && less_eq(buf_seqno(crs), n_ptr->bclink.acked)) skb_queue_walk(&bcl->outqueue, skb) {
crs = crs->next; if (more(buf_seqno(skb), n_ptr->bclink.acked))
break;
}
/* Update packets that node is now acknowledging */ /* Update packets that node is now acknowledging */
skb_queue_walk_from_safe(&bcl->outqueue, skb, tmp) {
if (more(buf_seqno(skb), acked))
break;
while (crs && less_eq(buf_seqno(crs), acked)) { next = tipc_skb_queue_next(&bcl->outqueue, skb);
next = crs->next; if (skb != bcl->next_out) {
bcbuf_decr_acks(skb);
if (crs != bcl->next_out) } else {
bcbuf_decr_acks(crs); bcbuf_set_acks(skb, 0);
else {
bcbuf_set_acks(crs, 0);
bcl->next_out = next; bcl->next_out = next;
bclink_set_last_sent(); bclink_set_last_sent();
} }
if (bcbuf_acks(crs) == 0) { if (bcbuf_acks(skb) == 0) {
bcl->first_out = next; __skb_unlink(skb, &bcl->outqueue);
bcl->out_queue_size--; kfree_skb(skb);
kfree_skb(crs);
released = 1; released = 1;
} }
crs = next;
} }
n_ptr->bclink.acked = acked; n_ptr->bclink.acked = acked;
/* Try resolving broadcast link congestion, if necessary */ /* Try resolving broadcast link congestion, if necessary */
if (unlikely(bcl->next_out)) { if (unlikely(bcl->next_out)) {
tipc_link_push_packets(bcl); tipc_link_push_packets(bcl);
bclink_set_last_sent(); bclink_set_last_sent();
@ -327,19 +328,16 @@ void tipc_bclink_update_link_state(struct tipc_node *n_ptr, u32 last_sent)
struct sk_buff *buf; struct sk_buff *buf;
/* Ignore "stale" link state info */ /* Ignore "stale" link state info */
if (less_eq(last_sent, n_ptr->bclink.last_in)) if (less_eq(last_sent, n_ptr->bclink.last_in))
return; return;
/* Update link synchronization state; quit if in sync */ /* Update link synchronization state; quit if in sync */
bclink_update_last_sent(n_ptr, last_sent); bclink_update_last_sent(n_ptr, last_sent);
if (n_ptr->bclink.last_sent == n_ptr->bclink.last_in) if (n_ptr->bclink.last_sent == n_ptr->bclink.last_in)
return; return;
/* Update out-of-sync state; quit if loss is still unconfirmed */ /* Update out-of-sync state; quit if loss is still unconfirmed */
if ((++n_ptr->bclink.oos_state) == 1) { if ((++n_ptr->bclink.oos_state) == 1) {
if (n_ptr->bclink.deferred_size < (TIPC_MIN_LINK_WIN / 2)) if (n_ptr->bclink.deferred_size < (TIPC_MIN_LINK_WIN / 2))
return; return;
@ -347,12 +345,10 @@ void tipc_bclink_update_link_state(struct tipc_node *n_ptr, u32 last_sent)
} }
/* Don't NACK if one has been recently sent (or seen) */ /* Don't NACK if one has been recently sent (or seen) */
if (n_ptr->bclink.oos_state & 0x1) if (n_ptr->bclink.oos_state & 0x1)
return; return;
/* Send NACK */ /* Send NACK */
buf = tipc_buf_acquire(INT_H_SIZE); buf = tipc_buf_acquire(INT_H_SIZE);
if (buf) { if (buf) {
struct tipc_msg *msg = buf_msg(buf); struct tipc_msg *msg = buf_msg(buf);
@ -425,9 +421,11 @@ int tipc_bclink_xmit(struct sk_buff *buf)
if (likely(bclink->bcast_nodes.count)) { if (likely(bclink->bcast_nodes.count)) {
rc = __tipc_link_xmit(bcl, buf); rc = __tipc_link_xmit(bcl, buf);
if (likely(!rc)) { if (likely(!rc)) {
u32 len = skb_queue_len(&bcl->outqueue);
bclink_set_last_sent(); bclink_set_last_sent();
bcl->stats.queue_sz_counts++; bcl->stats.queue_sz_counts++;
bcl->stats.accu_queue_sz += bcl->out_queue_size; bcl->stats.accu_queue_sz += len;
} }
bc = 1; bc = 1;
} }
@ -462,7 +460,6 @@ static void bclink_accept_pkt(struct tipc_node *node, u32 seqno)
* Unicast an ACK periodically, ensuring that * Unicast an ACK periodically, ensuring that
* all nodes in the cluster don't ACK at the same time * all nodes in the cluster don't ACK at the same time
*/ */
if (((seqno - tipc_own_addr) % TIPC_MIN_LINK_WIN) == 0) { if (((seqno - tipc_own_addr) % TIPC_MIN_LINK_WIN) == 0) {
tipc_link_proto_xmit(node->active_links[node->addr & 1], tipc_link_proto_xmit(node->active_links[node->addr & 1],
STATE_MSG, 0, 0, 0, 0, 0); STATE_MSG, 0, 0, 0, 0, 0);
@ -484,7 +481,6 @@ void tipc_bclink_rcv(struct sk_buff *buf)
int deferred = 0; int deferred = 0;
/* Screen out unwanted broadcast messages */ /* Screen out unwanted broadcast messages */
if (msg_mc_netid(msg) != tipc_net_id) if (msg_mc_netid(msg) != tipc_net_id)
goto exit; goto exit;
@ -497,7 +493,6 @@ void tipc_bclink_rcv(struct sk_buff *buf)
goto unlock; goto unlock;
/* Handle broadcast protocol message */ /* Handle broadcast protocol message */
if (unlikely(msg_user(msg) == BCAST_PROTOCOL)) { if (unlikely(msg_user(msg) == BCAST_PROTOCOL)) {
if (msg_type(msg) != STATE_MSG) if (msg_type(msg) != STATE_MSG)
goto unlock; goto unlock;
@ -518,14 +513,12 @@ void tipc_bclink_rcv(struct sk_buff *buf)
} }
/* Handle in-sequence broadcast message */ /* Handle in-sequence broadcast message */
seqno = msg_seqno(msg); seqno = msg_seqno(msg);
next_in = mod(node->bclink.last_in + 1); next_in = mod(node->bclink.last_in + 1);
if (likely(seqno == next_in)) { if (likely(seqno == next_in)) {
receive: receive:
/* Deliver message to destination */ /* Deliver message to destination */
if (likely(msg_isdata(msg))) { if (likely(msg_isdata(msg))) {
tipc_bclink_lock(); tipc_bclink_lock();
bclink_accept_pkt(node, seqno); bclink_accept_pkt(node, seqno);
@ -574,7 +567,6 @@ receive:
buf = NULL; buf = NULL;
/* Determine new synchronization state */ /* Determine new synchronization state */
tipc_node_lock(node); tipc_node_lock(node);
if (unlikely(!tipc_node_is_up(node))) if (unlikely(!tipc_node_is_up(node)))
goto unlock; goto unlock;
@ -594,7 +586,6 @@ receive:
goto unlock; goto unlock;
/* Take in-sequence message from deferred queue & deliver it */ /* Take in-sequence message from deferred queue & deliver it */
buf = node->bclink.deferred_head; buf = node->bclink.deferred_head;
node->bclink.deferred_head = buf->next; node->bclink.deferred_head = buf->next;
buf->next = NULL; buf->next = NULL;
@ -603,7 +594,6 @@ receive:
} }
/* Handle out-of-sequence broadcast message */ /* Handle out-of-sequence broadcast message */
if (less(next_in, seqno)) { if (less(next_in, seqno)) {
deferred = tipc_link_defer_pkt(&node->bclink.deferred_head, deferred = tipc_link_defer_pkt(&node->bclink.deferred_head,
&node->bclink.deferred_tail, &node->bclink.deferred_tail,
@ -963,6 +953,7 @@ int tipc_bclink_init(void)
sprintf(bcbearer->media.name, "tipc-broadcast"); sprintf(bcbearer->media.name, "tipc-broadcast");
spin_lock_init(&bclink->lock); spin_lock_init(&bclink->lock);
__skb_queue_head_init(&bcl->outqueue);
__skb_queue_head_init(&bcl->waiting_sks); __skb_queue_head_init(&bcl->waiting_sks);
bcl->next_out_no = 1; bcl->next_out_no = 1;
spin_lock_init(&bclink->node.lock); spin_lock_init(&bclink->node.lock);

190
net/tipc/link.c
View File

@ -171,14 +171,17 @@ int tipc_link_is_active(struct tipc_link *l_ptr)
*/ */
static void link_timeout(struct tipc_link *l_ptr) static void link_timeout(struct tipc_link *l_ptr)
{ {
struct sk_buff *skb;
tipc_node_lock(l_ptr->owner); tipc_node_lock(l_ptr->owner);
/* update counters used in statistical profiling of send traffic */ /* update counters used in statistical profiling of send traffic */
l_ptr->stats.accu_queue_sz += l_ptr->out_queue_size; l_ptr->stats.accu_queue_sz += skb_queue_len(&l_ptr->outqueue);
l_ptr->stats.queue_sz_counts++; l_ptr->stats.queue_sz_counts++;
if (l_ptr->first_out) { skb = skb_peek(&l_ptr->outqueue);
struct tipc_msg *msg = buf_msg(l_ptr->first_out); if (skb) {
struct tipc_msg *msg = buf_msg(skb);
u32 length = msg_size(msg); u32 length = msg_size(msg);
if ((msg_user(msg) == MSG_FRAGMENTER) && if ((msg_user(msg) == MSG_FRAGMENTER) &&
@ -206,7 +209,6 @@ static void link_timeout(struct tipc_link *l_ptr)
} }
/* do all other link processing performed on a periodic basis */ /* do all other link processing performed on a periodic basis */
link_state_event(l_ptr, TIMEOUT_EVT); link_state_event(l_ptr, TIMEOUT_EVT);
if (l_ptr->next_out) if (l_ptr->next_out)
@ -289,6 +291,7 @@ struct tipc_link *tipc_link_create(struct tipc_node *n_ptr,
link_init_max_pkt(l_ptr); link_init_max_pkt(l_ptr);
l_ptr->next_out_no = 1; l_ptr->next_out_no = 1;
__skb_queue_head_init(&l_ptr->outqueue);
__skb_queue_head_init(&l_ptr->waiting_sks); __skb_queue_head_init(&l_ptr->waiting_sks);
link_reset_statistics(l_ptr); link_reset_statistics(l_ptr);
@ -367,7 +370,7 @@ static bool link_schedule_user(struct tipc_link *link, u32 oport,
*/ */
static void link_prepare_wakeup(struct tipc_link *link) static void link_prepare_wakeup(struct tipc_link *link)
{ {
uint pend_qsz = link->out_queue_size; uint pend_qsz = skb_queue_len(&link->outqueue);
struct sk_buff *skb, *tmp; struct sk_buff *skb, *tmp;
skb_queue_walk_safe(&link->waiting_sks, skb, tmp) { skb_queue_walk_safe(&link->waiting_sks, skb, tmp) {
@ -379,17 +382,6 @@ static void link_prepare_wakeup(struct tipc_link *link)
} }
} }
/**
* link_release_outqueue - purge link's outbound message queue
* @l_ptr: pointer to link
*/
static void link_release_outqueue(struct tipc_link *l_ptr)
{
kfree_skb_list(l_ptr->first_out);
l_ptr->first_out = NULL;
l_ptr->out_queue_size = 0;
}
/** /**
* tipc_link_reset_fragments - purge link's inbound message fragments queue * tipc_link_reset_fragments - purge link's inbound message fragments queue
* @l_ptr: pointer to link * @l_ptr: pointer to link
@ -407,7 +399,7 @@ void tipc_link_reset_fragments(struct tipc_link *l_ptr)
void tipc_link_purge_queues(struct tipc_link *l_ptr) void tipc_link_purge_queues(struct tipc_link *l_ptr)
{ {
kfree_skb_list(l_ptr->oldest_deferred_in); kfree_skb_list(l_ptr->oldest_deferred_in);
kfree_skb_list(l_ptr->first_out); __skb_queue_purge(&l_ptr->outqueue);
tipc_link_reset_fragments(l_ptr); tipc_link_reset_fragments(l_ptr);
} }
@ -440,14 +432,12 @@ void tipc_link_reset(struct tipc_link *l_ptr)
} }
/* Clean up all queues: */ /* Clean up all queues: */
link_release_outqueue(l_ptr); __skb_queue_purge(&l_ptr->outqueue);
kfree_skb_list(l_ptr->oldest_deferred_in); kfree_skb_list(l_ptr->oldest_deferred_in);
if (!skb_queue_empty(&l_ptr->waiting_sks)) { if (!skb_queue_empty(&l_ptr->waiting_sks)) {
skb_queue_splice_init(&l_ptr->waiting_sks, &owner->waiting_sks); skb_queue_splice_init(&l_ptr->waiting_sks, &owner->waiting_sks);
owner->action_flags |= TIPC_WAKEUP_USERS; owner->action_flags |= TIPC_WAKEUP_USERS;
} }
l_ptr->last_out = NULL;
l_ptr->first_out = NULL;
l_ptr->next_out = NULL; l_ptr->next_out = NULL;
l_ptr->unacked_window = 0; l_ptr->unacked_window = 0;
l_ptr->checkpoint = 1; l_ptr->checkpoint = 1;
@ -703,18 +693,17 @@ drop:
/** /**
* __tipc_link_xmit(): same as tipc_link_xmit, but destlink is known & locked * __tipc_link_xmit(): same as tipc_link_xmit, but destlink is known & locked
* @link: link to use * @link: link to use
* @buf: chain of buffers containing message * @skb: chain of buffers containing message
* Consumes the buffer chain, except when returning -ELINKCONG * Consumes the buffer chain, except when returning -ELINKCONG
* Returns 0 if success, otherwise errno: -ELINKCONG, -EMSGSIZE (plain socket * Returns 0 if success, otherwise errno: -ELINKCONG, -EMSGSIZE (plain socket
* user data messages) or -EHOSTUNREACH (all other messages/senders) * user data messages) or -EHOSTUNREACH (all other messages/senders)
* Only the socket functions tipc_send_stream() and tipc_send_packet() need * Only the socket functions tipc_send_stream() and tipc_send_packet() need
* to act on the return value, since they may need to do more send attempts. * to act on the return value, since they may need to do more send attempts.
*/ */
int __tipc_link_xmit(struct tipc_link *link, struct sk_buff *buf) int __tipc_link_xmit(struct tipc_link *link, struct sk_buff *skb)
{ {
struct tipc_msg *msg = buf_msg(buf); struct tipc_msg *msg = buf_msg(skb);
uint psz = msg_size(msg); uint psz = msg_size(msg);
uint qsz = link->out_queue_size;
uint sndlim = link->queue_limit[0]; uint sndlim = link->queue_limit[0];
uint imp = tipc_msg_tot_importance(msg); uint imp = tipc_msg_tot_importance(msg);
uint mtu = link->max_pkt; uint mtu = link->max_pkt;
@ -722,58 +711,50 @@ int __tipc_link_xmit(struct tipc_link *link, struct sk_buff *buf)
uint seqno = link->next_out_no; uint seqno = link->next_out_no;
uint bc_last_in = link->owner->bclink.last_in; uint bc_last_in = link->owner->bclink.last_in;
struct tipc_media_addr *addr = &link->media_addr; struct tipc_media_addr *addr = &link->media_addr;
struct sk_buff *next = buf->next; struct sk_buff_head *outqueue = &link->outqueue;
struct sk_buff *next;
/* Match queue limits against msg importance: */ /* Match queue limits against msg importance: */
if (unlikely(qsz >= link->queue_limit[imp])) if (unlikely(skb_queue_len(outqueue) >= link->queue_limit[imp]))
return tipc_link_cong(link, buf); return tipc_link_cong(link, skb);
/* Has valid packet limit been used ? */ /* Has valid packet limit been used ? */
if (unlikely(psz > mtu)) { if (unlikely(psz > mtu)) {
kfree_skb_list(buf); kfree_skb_list(skb);
return -EMSGSIZE; return -EMSGSIZE;
} }
/* Prepare each packet for sending, and add to outqueue: */ /* Prepare each packet for sending, and add to outqueue: */
while (buf) { while (skb) {
next = buf->next; next = skb->next;
msg = buf_msg(buf); msg = buf_msg(skb);
msg_set_word(msg, 2, ((ack << 16) | mod(seqno))); msg_set_word(msg, 2, ((ack << 16) | mod(seqno)));
msg_set_bcast_ack(msg, bc_last_in); msg_set_bcast_ack(msg, bc_last_in);
if (!link->first_out) { if (skb_queue_len(outqueue) < sndlim) {
link->first_out = buf; __skb_queue_tail(outqueue, skb);
} else if (qsz < sndlim) { tipc_bearer_send(link->bearer_id, skb, addr);
link->last_out->next = buf; link->next_out = NULL;
} else if (tipc_msg_bundle(link->last_out, buf, mtu)) { link->unacked_window = 0;
} else if (tipc_msg_bundle(outqueue, skb, mtu)) {
link->stats.sent_bundled++; link->stats.sent_bundled++;
buf = next; skb = next;
next = buf->next;
continue; continue;
} else if (tipc_msg_make_bundle(&buf, mtu, link->addr)) { } else if (tipc_msg_make_bundle(outqueue, skb, mtu,
link->addr)) {
link->stats.sent_bundled++; link->stats.sent_bundled++;
link->stats.sent_bundles++; link->stats.sent_bundles++;
link->last_out->next = buf;
if (!link->next_out) if (!link->next_out)
link->next_out = buf; link->next_out = skb_peek_tail(outqueue);
} else { } else {
link->last_out->next = buf; __skb_queue_tail(outqueue, skb);
if (!link->next_out) if (!link->next_out)
link->next_out = buf; link->next_out = skb;
}
/* Send packet if possible: */
if (likely(++qsz <= sndlim)) {
tipc_bearer_send(link->bearer_id, buf, addr);
link->next_out = next;
link->unacked_window = 0;
} }
seqno++; seqno++;
link->last_out = buf; skb = next;
buf = next;
} }
link->next_out_no = seqno; link->next_out_no = seqno;
link->out_queue_size = qsz;
return 0; return 0;
} }
@ -851,6 +832,14 @@ static void tipc_link_sync_rcv(struct tipc_node *n, struct sk_buff *buf)
kfree_skb(buf); kfree_skb(buf);
} }
struct sk_buff *tipc_skb_queue_next(const struct sk_buff_head *list,
const struct sk_buff *skb)
{
if (skb_queue_is_last(list, skb))
return NULL;
return skb->next;
}
/* /*
* tipc_link_push_packets - push unsent packets to bearer * tipc_link_push_packets - push unsent packets to bearer
* *
@ -861,15 +850,15 @@ static void tipc_link_sync_rcv(struct tipc_node *n, struct sk_buff *buf)
*/ */
void tipc_link_push_packets(struct tipc_link *l_ptr) void tipc_link_push_packets(struct tipc_link *l_ptr)
{ {
struct sk_buff *skb; struct sk_buff_head *outqueue = &l_ptr->outqueue;
struct sk_buff *skb = l_ptr->next_out;
struct tipc_msg *msg; struct tipc_msg *msg;
u32 next, first; u32 next, first;
while (l_ptr->next_out) { skb_queue_walk_from(outqueue, skb) {
skb = l_ptr->next_out;
msg = buf_msg(skb); msg = buf_msg(skb);
next = msg_seqno(msg); next = msg_seqno(msg);
first = buf_seqno(l_ptr->first_out); first = buf_seqno(skb_peek(outqueue));
if (mod(next - first) < l_ptr->queue_limit[0]) { if (mod(next - first) < l_ptr->queue_limit[0]) {
msg_set_ack(msg, mod(l_ptr->next_in_no - 1)); msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
@ -878,7 +867,7 @@ void tipc_link_push_packets(struct tipc_link *l_ptr)
TIPC_SKB_CB(skb)->bundling = false; TIPC_SKB_CB(skb)->bundling = false;
tipc_bearer_send(l_ptr->bearer_id, skb, tipc_bearer_send(l_ptr->bearer_id, skb,
&l_ptr->media_addr); &l_ptr->media_addr);
l_ptr->next_out = skb->next; l_ptr->next_out = tipc_skb_queue_next(outqueue, skb);
} else { } else {
break; break;
} }
@ -946,20 +935,20 @@ static void link_retransmit_failure(struct tipc_link *l_ptr,
} }
} }
void tipc_link_retransmit(struct tipc_link *l_ptr, struct sk_buff *buf, void tipc_link_retransmit(struct tipc_link *l_ptr, struct sk_buff *skb,
u32 retransmits) u32 retransmits)
{ {
struct tipc_msg *msg; struct tipc_msg *msg;
if (!buf) if (!skb)
return; return;
msg = buf_msg(buf); msg = buf_msg(skb);
/* Detect repeated retransmit failures */ /* Detect repeated retransmit failures */
if (l_ptr->last_retransmitted == msg_seqno(msg)) { if (l_ptr->last_retransmitted == msg_seqno(msg)) {
if (++l_ptr->stale_count > 100) { if (++l_ptr->stale_count > 100) {
link_retransmit_failure(l_ptr, buf); link_retransmit_failure(l_ptr, skb);
return; return;
} }
} else { } else {
@ -967,12 +956,13 @@ void tipc_link_retransmit(struct tipc_link *l_ptr, struct sk_buff *buf,
l_ptr->stale_count = 1; l_ptr->stale_count = 1;
} }
while (retransmits && (buf != l_ptr->next_out) && buf) { skb_queue_walk_from(&l_ptr->outqueue, skb) {
msg = buf_msg(buf); if (!retransmits || skb == l_ptr->next_out)
break;
msg = buf_msg(skb);
msg_set_ack(msg, mod(l_ptr->next_in_no - 1)); msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in); msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
tipc_bearer_send(l_ptr->bearer_id, buf, &l_ptr->media_addr); tipc_bearer_send(l_ptr->bearer_id, skb, &l_ptr->media_addr);
buf = buf->next;
retransmits--; retransmits--;
l_ptr->stats.retransmitted++; l_ptr->stats.retransmitted++;
} }
@ -1067,12 +1057,12 @@ void tipc_rcv(struct sk_buff *head, struct tipc_bearer *b_ptr)
while (head) { while (head) {
struct tipc_node *n_ptr; struct tipc_node *n_ptr;
struct tipc_link *l_ptr; struct tipc_link *l_ptr;
struct sk_buff *crs;
struct sk_buff *buf = head; struct sk_buff *buf = head;
struct sk_buff *skb1, *tmp;
struct tipc_msg *msg; struct tipc_msg *msg;
u32 seq_no; u32 seq_no;
u32 ackd; u32 ackd;
u32 released = 0; u32 released;
head = head->next; head = head->next;
buf->next = NULL; buf->next = NULL;
@ -1131,17 +1121,14 @@ void tipc_rcv(struct sk_buff *head, struct tipc_bearer *b_ptr)
if (n_ptr->bclink.recv_permitted) if (n_ptr->bclink.recv_permitted)
tipc_bclink_acknowledge(n_ptr, msg_bcast_ack(msg)); tipc_bclink_acknowledge(n_ptr, msg_bcast_ack(msg));
crs = l_ptr->first_out; released = 0;
while ((crs != l_ptr->next_out) && skb_queue_walk_safe(&l_ptr->outqueue, skb1, tmp) {
less_eq(buf_seqno(crs), ackd)) { if (skb1 == l_ptr->next_out ||
struct sk_buff *next = crs->next; more(buf_seqno(skb1), ackd))
kfree_skb(crs); break;
crs = next; __skb_unlink(skb1, &l_ptr->outqueue);
released++; kfree_skb(skb1);
} released = 1;
if (released) {
l_ptr->first_out = crs;
l_ptr->out_queue_size -= released;
} }
/* Try sending any messages link endpoint has pending */ /* Try sending any messages link endpoint has pending */
@ -1590,7 +1577,7 @@ static void tipc_link_proto_rcv(struct tipc_link *l_ptr, struct sk_buff *buf)
} }
if (msg_seq_gap(msg)) { if (msg_seq_gap(msg)) {
l_ptr->stats.recv_nacks++; l_ptr->stats.recv_nacks++;
tipc_link_retransmit(l_ptr, l_ptr->first_out, tipc_link_retransmit(l_ptr, skb_peek(&l_ptr->outqueue),
msg_seq_gap(msg)); msg_seq_gap(msg));
} }
break; break;
@ -1637,10 +1624,10 @@ static void tipc_link_tunnel_xmit(struct tipc_link *l_ptr,
*/ */
void tipc_link_failover_send_queue(struct tipc_link *l_ptr) void tipc_link_failover_send_queue(struct tipc_link *l_ptr)
{ {
u32 msgcount = l_ptr->out_queue_size; u32 msgcount = skb_queue_len(&l_ptr->outqueue);
struct sk_buff *crs = l_ptr->first_out;
struct tipc_link *tunnel = l_ptr->owner->active_links[0]; struct tipc_link *tunnel = l_ptr->owner->active_links[0];
struct tipc_msg tunnel_hdr; struct tipc_msg tunnel_hdr;
struct sk_buff *skb;
int split_bundles; int split_bundles;
if (!tunnel) if (!tunnel)
@ -1651,14 +1638,12 @@ void tipc_link_failover_send_queue(struct tipc_link *l_ptr)
msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id); msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
msg_set_msgcnt(&tunnel_hdr, msgcount); msg_set_msgcnt(&tunnel_hdr, msgcount);
if (!l_ptr->first_out) { if (skb_queue_empty(&l_ptr->outqueue)) {
struct sk_buff *buf; skb = tipc_buf_acquire(INT_H_SIZE);
if (skb) {
buf = tipc_buf_acquire(INT_H_SIZE); skb_copy_to_linear_data(skb, &tunnel_hdr, INT_H_SIZE);
if (buf) {
skb_copy_to_linear_data(buf, &tunnel_hdr, INT_H_SIZE);
msg_set_size(&tunnel_hdr, INT_H_SIZE); msg_set_size(&tunnel_hdr, INT_H_SIZE);
__tipc_link_xmit(tunnel, buf); __tipc_link_xmit(tunnel, skb);
} else { } else {
pr_warn("%sunable to send changeover msg\n", pr_warn("%sunable to send changeover msg\n",
link_co_err); link_co_err);
@ -1669,8 +1654,8 @@ void tipc_link_failover_send_queue(struct tipc_link *l_ptr)
split_bundles = (l_ptr->owner->active_links[0] != split_bundles = (l_ptr->owner->active_links[0] !=
l_ptr->owner->active_links[1]); l_ptr->owner->active_links[1]);
while (crs) { skb_queue_walk(&l_ptr->outqueue, skb) {
struct tipc_msg *msg = buf_msg(crs); struct tipc_msg *msg = buf_msg(skb);
if ((msg_user(msg) == MSG_BUNDLER) && split_bundles) { if ((msg_user(msg) == MSG_BUNDLER) && split_bundles) {
struct tipc_msg *m = msg_get_wrapped(msg); struct tipc_msg *m = msg_get_wrapped(msg);
@ -1688,7 +1673,6 @@ void tipc_link_failover_send_queue(struct tipc_link *l_ptr)
tipc_link_tunnel_xmit(l_ptr, &tunnel_hdr, msg, tipc_link_tunnel_xmit(l_ptr, &tunnel_hdr, msg,
msg_link_selector(msg)); msg_link_selector(msg));
} }
crs = crs->next;
} }
} }
@ -1704,17 +1688,16 @@ void tipc_link_failover_send_queue(struct tipc_link *l_ptr)
void tipc_link_dup_queue_xmit(struct tipc_link *l_ptr, void tipc_link_dup_queue_xmit(struct tipc_link *l_ptr,
struct tipc_link *tunnel) struct tipc_link *tunnel)
{ {
struct sk_buff *iter; struct sk_buff *skb;
struct tipc_msg tunnel_hdr; struct tipc_msg tunnel_hdr;
tipc_msg_init(&tunnel_hdr, CHANGEOVER_PROTOCOL, tipc_msg_init(&tunnel_hdr, CHANGEOVER_PROTOCOL,
DUPLICATE_MSG, INT_H_SIZE, l_ptr->addr); DUPLICATE_MSG, INT_H_SIZE, l_ptr->addr);
msg_set_msgcnt(&tunnel_hdr, l_ptr->out_queue_size); msg_set_msgcnt(&tunnel_hdr, skb_queue_len(&l_ptr->outqueue));
msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id); msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
iter = l_ptr->first_out; skb_queue_walk(&l_ptr->outqueue, skb) {
while (iter) { struct sk_buff *outskb;
struct sk_buff *outbuf; struct tipc_msg *msg = buf_msg(skb);
struct tipc_msg *msg = buf_msg(iter);
u32 length = msg_size(msg); u32 length = msg_size(msg);
if (msg_user(msg) == MSG_BUNDLER) if (msg_user(msg) == MSG_BUNDLER)
@ -1722,19 +1705,18 @@ void tipc_link_dup_queue_xmit(struct tipc_link *l_ptr,
msg_set_ack(msg, mod(l_ptr->next_in_no - 1)); /* Update */ msg_set_ack(msg, mod(l_ptr->next_in_no - 1)); /* Update */
msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in); msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
msg_set_size(&tunnel_hdr, length + INT_H_SIZE); msg_set_size(&tunnel_hdr, length + INT_H_SIZE);
outbuf = tipc_buf_acquire(length + INT_H_SIZE); outskb = tipc_buf_acquire(length + INT_H_SIZE);
if (outbuf == NULL) { if (outskb == NULL) {
pr_warn("%sunable to send duplicate msg\n", pr_warn("%sunable to send duplicate msg\n",
link_co_err); link_co_err);
return; return;
} }
skb_copy_to_linear_data(outbuf, &tunnel_hdr, INT_H_SIZE); skb_copy_to_linear_data(outskb, &tunnel_hdr, INT_H_SIZE);
skb_copy_to_linear_data_offset(outbuf, INT_H_SIZE, iter->data, skb_copy_to_linear_data_offset(outskb, INT_H_SIZE, skb->data,
length); length);
__tipc_link_xmit(tunnel, outbuf); __tipc_link_xmit(tunnel, outskb);
if (!tipc_link_is_up(l_ptr)) if (!tipc_link_is_up(l_ptr))
return; return;
iter = iter->next;
} }
} }

17
net/tipc/link.h
View File

@ -119,9 +119,7 @@ struct tipc_stats {
* @max_pkt: current maximum packet size for this link * @max_pkt: current maximum packet size for this link
* @max_pkt_target: desired maximum packet size for this link * @max_pkt_target: desired maximum packet size for this link
* @max_pkt_probes: # of probes based on current (max_pkt, max_pkt_target) * @max_pkt_probes: # of probes based on current (max_pkt, max_pkt_target)
* @out_queue_size: # of messages in outbound message queue * @outqueue: outbound message queue
* @first_out: ptr to first outbound message in queue
* @last_out: ptr to last outbound message in queue
* @next_out_no: next sequence number to use for outbound messages * @next_out_no: next sequence number to use for outbound messages
* @last_retransmitted: sequence number of most recently retransmitted message * @last_retransmitted: sequence number of most recently retransmitted message
* @stale_count: # of identical retransmit requests made by peer * @stale_count: # of identical retransmit requests made by peer
@ -173,9 +171,7 @@ struct tipc_link {
u32 max_pkt_probes; u32 max_pkt_probes;
/* Sending */ /* Sending */
u32 out_queue_size; struct sk_buff_head outqueue;
struct sk_buff *first_out;
struct sk_buff *last_out;
u32 next_out_no; u32 next_out_no;
u32 last_retransmitted; u32 last_retransmitted;
u32 stale_count; u32 stale_count;
@ -233,6 +229,8 @@ u32 tipc_link_defer_pkt(struct sk_buff **head, struct sk_buff **tail,
void tipc_link_set_queue_limits(struct tipc_link *l_ptr, u32 window); void tipc_link_set_queue_limits(struct tipc_link *l_ptr, u32 window);
void tipc_link_retransmit(struct tipc_link *l_ptr, void tipc_link_retransmit(struct tipc_link *l_ptr,
struct sk_buff *start, u32 retransmits); struct sk_buff *start, u32 retransmits);
struct sk_buff *tipc_skb_queue_next(const struct sk_buff_head *list,
const struct sk_buff *skb);
int tipc_nl_link_dump(struct sk_buff *skb, struct netlink_callback *cb); int tipc_nl_link_dump(struct sk_buff *skb, struct netlink_callback *cb);
int tipc_nl_link_get(struct sk_buff *skb, struct genl_info *info); int tipc_nl_link_get(struct sk_buff *skb, struct genl_info *info);
@ -258,6 +256,11 @@ static inline int less_eq(u32 left, u32 right)
return mod(right - left) < 32768u; return mod(right - left) < 32768u;
} }
static inline int more(u32 left, u32 right)
{
return !less_eq(left, right);
}
static inline int less(u32 left, u32 right) static inline int less(u32 left, u32 right)
{ {
return less_eq(left, right) && (mod(right) != mod(left)); return less_eq(left, right) && (mod(right) != mod(left));
@ -294,7 +297,7 @@ static inline int link_reset_reset(struct tipc_link *l_ptr)
static inline int link_congested(struct tipc_link *l_ptr) static inline int link_congested(struct tipc_link *l_ptr)
{ {
return l_ptr->out_queue_size >= l_ptr->queue_limit[0]; return skb_queue_len(&l_ptr->outqueue) >= l_ptr->queue_limit[0];
} }
#endif #endif

50
net/tipc/msg.c
View File

@ -265,16 +265,17 @@ error:
/** /**
* tipc_msg_bundle(): Append contents of a buffer to tail of an existing one * tipc_msg_bundle(): Append contents of a buffer to tail of an existing one
* @bbuf: the existing buffer ("bundle") * @list: the buffer chain of the existing buffer ("bundle")
* @buf: buffer to be appended * @skb: buffer to be appended
* @mtu: max allowable size for the bundle buffer * @mtu: max allowable size for the bundle buffer
* Consumes buffer if successful * Consumes buffer if successful
* Returns true if bundling could be performed, otherwise false * Returns true if bundling could be performed, otherwise false
*/ */
bool tipc_msg_bundle(struct sk_buff *bbuf, struct sk_buff *buf, u32 mtu) bool tipc_msg_bundle(struct sk_buff_head *list, struct sk_buff *skb, u32 mtu)
{ {
struct tipc_msg *bmsg = buf_msg(bbuf); struct sk_buff *bskb = skb_peek_tail(list);
struct tipc_msg *msg = buf_msg(buf); struct tipc_msg *bmsg = buf_msg(bskb);
struct tipc_msg *msg = buf_msg(skb);
unsigned int bsz = msg_size(bmsg); unsigned int bsz = msg_size(bmsg);
unsigned int msz = msg_size(msg); unsigned int msz = msg_size(msg);
u32 start = align(bsz); u32 start = align(bsz);
@ -289,35 +290,36 @@ bool tipc_msg_bundle(struct sk_buff *bbuf, struct sk_buff *buf, u32 mtu)
return false; return false;
if (likely(msg_user(bmsg) != MSG_BUNDLER)) if (likely(msg_user(bmsg) != MSG_BUNDLER))
return false; return false;
if (likely(!TIPC_SKB_CB(bbuf)->bundling)) if (likely(!TIPC_SKB_CB(bskb)->bundling))
return false; return false;
if (unlikely(skb_tailroom(bbuf) < (pad + msz))) if (unlikely(skb_tailroom(bskb) < (pad + msz)))
return false; return false;
if (unlikely(max < (start + msz))) if (unlikely(max < (start + msz)))
return false; return false;
skb_put(bbuf, pad + msz); skb_put(bskb, pad + msz);
skb_copy_to_linear_data_offset(bbuf, start, buf->data, msz); skb_copy_to_linear_data_offset(bskb, start, skb->data, msz);
msg_set_size(bmsg, start + msz); msg_set_size(bmsg, start + msz);
msg_set_msgcnt(bmsg, msg_msgcnt(bmsg) + 1); msg_set_msgcnt(bmsg, msg_msgcnt(bmsg) + 1);
bbuf->next = buf->next; kfree_skb(skb);
kfree_skb(buf);
return true; return true;
} }
/** /**
* tipc_msg_make_bundle(): Create bundle buf and append message to its tail * tipc_msg_make_bundle(): Create bundle buf and append message to its tail
* @buf: buffer to be appended and replaced * @list: the buffer chain
* @mtu: max allowable size for the bundle buffer, inclusive header * @skb: buffer to be appended and replaced
* @mtu: max allowable size for the bundle buffer, inclusive header
* @dnode: destination node for message. (Not always present in header) * @dnode: destination node for message. (Not always present in header)
* Replaces buffer if successful * Replaces buffer if successful
* Returns true if success, otherwise false * Returns true if success, otherwise false
*/ */
bool tipc_msg_make_bundle(struct sk_buff **buf, u32 mtu, u32 dnode) bool tipc_msg_make_bundle(struct sk_buff_head *list, struct sk_buff *skb,
u32 mtu, u32 dnode)
{ {
struct sk_buff *bbuf; struct sk_buff *bskb;
struct tipc_msg *bmsg; struct tipc_msg *bmsg;
struct tipc_msg *msg = buf_msg(*buf); struct tipc_msg *msg = buf_msg(skb);
u32 msz = msg_size(msg); u32 msz = msg_size(msg);
u32 max = mtu - INT_H_SIZE; u32 max = mtu - INT_H_SIZE;
@ -330,21 +332,19 @@ bool tipc_msg_make_bundle(struct sk_buff **buf, u32 mtu, u32 dnode)
if (msz > (max / 2)) if (msz > (max / 2))
return false; return false;
bbuf = tipc_buf_acquire(max); bskb = tipc_buf_acquire(max);
if (!bbuf) if (!bskb)
return false; return false;
skb_trim(bbuf, INT_H_SIZE); skb_trim(bskb, INT_H_SIZE);
bmsg = buf_msg(bbuf); bmsg = buf_msg(bskb);
tipc_msg_init(bmsg, MSG_BUNDLER, 0, INT_H_SIZE, dnode); tipc_msg_init(bmsg, MSG_BUNDLER, 0, INT_H_SIZE, dnode);
msg_set_seqno(bmsg, msg_seqno(msg)); msg_set_seqno(bmsg, msg_seqno(msg));
msg_set_ack(bmsg, msg_ack(msg)); msg_set_ack(bmsg, msg_ack(msg));
msg_set_bcast_ack(bmsg, msg_bcast_ack(msg)); msg_set_bcast_ack(bmsg, msg_bcast_ack(msg));
bbuf->next = (*buf)->next; TIPC_SKB_CB(bskb)->bundling = true;
TIPC_SKB_CB(bbuf)->bundling = true; __skb_queue_tail(list, bskb);
tipc_msg_bundle(bbuf, *buf, mtu); return tipc_msg_bundle(list, skb, mtu);
*buf = bbuf;
return true;
} }
/** /**

5
net/tipc/msg.h
View File

@ -734,9 +734,10 @@ struct sk_buff *tipc_msg_create(uint user, uint type, uint hdr_sz,
int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf); int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf);
bool tipc_msg_bundle(struct sk_buff *bbuf, struct sk_buff *buf, u32 mtu); bool tipc_msg_bundle(struct sk_buff_head *list, struct sk_buff *skb, u32 mtu);
bool tipc_msg_make_bundle(struct sk_buff **buf, u32 mtu, u32 dnode); bool tipc_msg_make_bundle(struct sk_buff_head *list, struct sk_buff *skb,
u32 mtu, u32 dnode);
int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m, int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m,
int offset, int dsz, int mtu , struct sk_buff **chain); int offset, int dsz, int mtu , struct sk_buff **chain);