Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-22 20:22:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

net/af_iucv: don't track individual TX skbs for TRANS_HIPER sockets

Browse Source 
Stop maintaining the skb_send_q list for TRANS_HIPER sockets.

Not only is it extra overhead, but keeping around a list of skb clones
means that we later also have to match the ->sk_txnotify() calls
against these clones and free them accordingly.
The current matching logic (comparing the skbs' shinfo location) is
frustratingly fragile, and breaks if the skb's head is mangled in any
sort of way while passing from dev_queue_xmit() to the device's
HW queue.

Also adjust the interface for ->sk_txnotify(), to make clear that we
don't actually care about any skb internals.

Signed-off-by: Julian Wiedmann <jwi@linux.ibm.com>
Acked-by: Willem de Bruijn <willemb@google.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
This commit is contained in:
Julian Wiedmann 2021-01-28 12:41:07 +01:00 committed by Jakub Kicinski
parent ef6af7bdb9
commit 80bc97aa0a
3 changed files with 26 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
drivers/s390/net/qeth_core_main.c
View File

@ -1409,10 +1409,12 @@ static void qeth_notify_skbs(struct qeth_qdio_out_q *q,
struct sk_buff *skb; struct sk_buff *skb;
skb_queue_walk(&buf->skb_list, skb) { skb_queue_walk(&buf->skb_list, skb) {
struct sock *sk = skb->sk;
QETH_CARD_TEXT_(q->card, 5, "skbn%d", notification); QETH_CARD_TEXT_(q->card, 5, "skbn%d", notification);
QETH_CARD_TEXT_(q->card, 5, "%lx", (long) skb); QETH_CARD_TEXT_(q->card, 5, "%lx", (long) skb);
if (skb->sk && skb->sk->sk_family == PF_IUCV) if (sk && sk->sk_family == PF_IUCV)
iucv_sk(skb->sk)->sk_txnotify(skb, notification); iucv_sk(sk)->sk_txnotify(sk, notification);
} }
} }

2
include/net/iucv/af_iucv.h
View File

@ -133,7 +133,7 @@ struct iucv_sock {
atomic_t msg_recv; atomic_t msg_recv;
atomic_t pendings; atomic_t pendings;
int transport; int transport;
void (*sk_txnotify)(struct sk_buff *skb, void (*sk_txnotify)(struct sock *sk,
enum iucv_tx_notify n); enum iucv_tx_notify n);
}; };

80
net/iucv/af_iucv.c
View File

@ -89,7 +89,7 @@ static struct sock *iucv_accept_dequeue(struct sock *parent,
static void iucv_sock_kill(struct sock *sk); static void iucv_sock_kill(struct sock *sk);
static void iucv_sock_close(struct sock *sk); static void iucv_sock_close(struct sock *sk);
static void afiucv_hs_callback_txnotify(struct sk_buff *, enum iucv_tx_notify); static void afiucv_hs_callback_txnotify(struct sock *sk, enum iucv_tx_notify);
/* Call Back functions */ /* Call Back functions */
static void iucv_callback_rx(struct iucv_path *, struct iucv_message *); static void iucv_callback_rx(struct iucv_path *, struct iucv_message *);
@ -211,7 +211,6 @@ static int afiucv_hs_send(struct iucv_message *imsg, struct sock *sock,
{ {
struct iucv_sock *iucv = iucv_sk(sock); struct iucv_sock *iucv = iucv_sk(sock);
struct af_iucv_trans_hdr *phs_hdr; struct af_iucv_trans_hdr *phs_hdr;
struct sk_buff *nskb;
int err, confirm_recv = 0; int err, confirm_recv = 0;
phs_hdr = skb_push(skb, sizeof(*phs_hdr)); phs_hdr = skb_push(skb, sizeof(*phs_hdr));
@ -261,20 +260,10 @@ static int afiucv_hs_send(struct iucv_message *imsg, struct sock *sock,
} }
skb->protocol = cpu_to_be16(ETH_P_AF_IUCV); skb->protocol = cpu_to_be16(ETH_P_AF_IUCV);
__skb_header_release(skb);
nskb = skb_clone(skb, GFP_ATOMIC);
if (!nskb) {
err = -ENOMEM;
goto err_free;
}
skb_queue_tail(&iucv->send_skb_q, nskb);
atomic_inc(&iucv->skbs_in_xmit); atomic_inc(&iucv->skbs_in_xmit);
err = dev_queue_xmit(skb); err = dev_queue_xmit(skb);
if (net_xmit_eval(err)) { if (net_xmit_eval(err)) {
atomic_dec(&iucv->skbs_in_xmit); atomic_dec(&iucv->skbs_in_xmit);
skb_unlink(nskb, &iucv->send_skb_q);
kfree_skb(nskb);
} else { } else {
atomic_sub(confirm_recv, &iucv->msg_recv); atomic_sub(confirm_recv, &iucv->msg_recv);
WARN_ON(atomic_read(&iucv->msg_recv) < 0); WARN_ON(atomic_read(&iucv->msg_recv) < 0);
@ -2146,59 +2135,33 @@ static int afiucv_hs_rcv(struct sk_buff *skb, struct net_device *dev,
* afiucv_hs_callback_txnotify() - handle send notifcations from HiperSockets * afiucv_hs_callback_txnotify() - handle send notifcations from HiperSockets
* transport * transport
**/ **/
static void afiucv_hs_callback_txnotify(struct sk_buff *skb, static void afiucv_hs_callback_txnotify(struct sock *sk, enum iucv_tx_notify n)
enum iucv_tx_notify n)
{ {
struct iucv_sock *iucv = iucv_sk(skb->sk); struct iucv_sock *iucv = iucv_sk(sk);
struct sock *sk = skb->sk;
struct sk_buff_head *list;
struct sk_buff *list_skb;
struct sk_buff *nskb;
unsigned long flags;
if (sock_flag(sk, SOCK_ZAPPED)) if (sock_flag(sk, SOCK_ZAPPED))
return; return;
list = &iucv->send_skb_q; switch (n) {
spin_lock_irqsave(&list->lock, flags); case TX_NOTIFY_OK:
skb_queue_walk_safe(list, list_skb, nskb) { atomic_dec(&iucv->skbs_in_xmit);
if (skb_shinfo(list_skb) == skb_shinfo(skb)) { iucv_sock_wake_msglim(sk);
switch (n) { break;
case TX_NOTIFY_OK: case TX_NOTIFY_PENDING:
atomic_dec(&iucv->skbs_in_xmit); atomic_inc(&iucv->pendings);
__skb_unlink(list_skb, list); break;
kfree_skb(list_skb); case TX_NOTIFY_DELAYED_OK:
iucv_sock_wake_msglim(sk); atomic_dec(&iucv->skbs_in_xmit);
break; if (atomic_dec_return(&iucv->pendings) <= 0)
case TX_NOTIFY_PENDING: iucv_sock_wake_msglim(sk);
atomic_inc(&iucv->pendings); break;
break; default:
case TX_NOTIFY_DELAYED_OK: atomic_dec(&iucv->skbs_in_xmit);
atomic_dec(&iucv->skbs_in_xmit); if (sk->sk_state == IUCV_CONNECTED) {
__skb_unlink(list_skb, list); sk->sk_state = IUCV_DISCONN;
atomic_dec(&iucv->pendings); sk->sk_state_change(sk);
if (atomic_read(&iucv->pendings) <= 0)
iucv_sock_wake_msglim(sk);
kfree_skb(list_skb);
break;
case TX_NOTIFY_UNREACHABLE:
case TX_NOTIFY_DELAYED_UNREACHABLE:
case TX_NOTIFY_TPQFULL: /* not yet used */
case TX_NOTIFY_GENERALERROR:
case TX_NOTIFY_DELAYED_GENERALERROR:
atomic_dec(&iucv->skbs_in_xmit);
__skb_unlink(list_skb, list);
kfree_skb(list_skb);
if (sk->sk_state == IUCV_CONNECTED) {
sk->sk_state = IUCV_DISCONN;
sk->sk_state_change(sk);
}
break;
}
break;
} }
} }
spin_unlock_irqrestore(&list->lock, flags);
if (sk->sk_state == IUCV_CLOSING) { if (sk->sk_state == IUCV_CLOSING) {
if (atomic_read(&iucv->skbs_in_xmit) == 0) { if (atomic_read(&iucv->skbs_in_xmit) == 0) {
@ -2206,7 +2169,6 @@ static void afiucv_hs_callback_txnotify(struct sk_buff *skb,
sk->sk_state_change(sk); sk->sk_state_change(sk);
} }
} }
} }
/* /*