iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

crypto/chelsio/chtls: listen fails with multiadapt

Browse Source 
listen fails when more than one tls capable device is
registered. tls_hw_hash is called for each dev which loops
again for each cdev_list causing listen failure. Hence
call chtls_listen_start/stop for specific device than loop over all
devices.

Signed-off-by: Atul Gupta <atul.gupta@chelsio.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Atul Gupta 2018-12-11 02:20:26 -08:00 committed by David S. Miller
parent df9d4a1780
commit 6422ccc5fb
2 changed files with 36 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
drivers/crypto/chelsio/chtls/chtls.h
View File

@ -153,6 +153,11 @@ struct chtls_dev {
unsigned int cdev_state; unsigned int cdev_state;
}; };
struct chtls_listen {
struct chtls_dev *cdev;
struct sock *sk;
};
struct chtls_hws { struct chtls_hws {
struct sk_buff_head sk_recv_queue; struct sk_buff_head sk_recv_queue;
u8 txqid; u8 txqid;

50
drivers/crypto/chelsio/chtls/chtls_main.c
View File

@ -55,24 +55,19 @@ static void unregister_listen_notifier(struct notifier_block *nb)
static int listen_notify_handler(struct notifier_block *this, static int listen_notify_handler(struct notifier_block *this,
unsigned long event, void *data) unsigned long event, void *data)
{ {
struct chtls_dev *cdev; struct chtls_listen *clisten;
struct sock *sk; int ret = NOTIFY_DONE;
int ret;
sk = data; clisten = (struct chtls_listen *)data;
ret = NOTIFY_DONE;
switch (event) { switch (event) {
case CHTLS_LISTEN_START: case CHTLS_LISTEN_START:
ret = chtls_listen_start(clisten->cdev, clisten->sk);
kfree(clisten);
break;
case CHTLS_LISTEN_STOP: case CHTLS_LISTEN_STOP:
mutex_lock(&cdev_list_lock); chtls_listen_stop(clisten->cdev, clisten->sk);
list_for_each_entry(cdev, &cdev_list, list) { kfree(clisten);
if (event == CHTLS_LISTEN_START)
ret = chtls_listen_start(cdev, sk);
else
chtls_listen_stop(cdev, sk);
}
mutex_unlock(&cdev_list_lock);
break; break;
} }
return ret; return ret;
@ -90,8 +85,9 @@ static int listen_backlog_rcv(struct sock *sk, struct sk_buff *skb)
return 0; return 0;
} }
static int chtls_start_listen(struct sock *sk) static int chtls_start_listen(struct chtls_dev *cdev, struct sock *sk)
{ {
struct chtls_listen *clisten;
int err; int err;
if (sk->sk_protocol != IPPROTO_TCP) if (sk->sk_protocol != IPPROTO_TCP)
@ -102,21 +98,33 @@ static int chtls_start_listen(struct sock *sk)
return -EADDRNOTAVAIL; return -EADDRNOTAVAIL;
sk->sk_backlog_rcv = listen_backlog_rcv; sk->sk_backlog_rcv = listen_backlog_rcv;
clisten = kmalloc(sizeof(*clisten), GFP_KERNEL);
if (!clisten)
return -ENOMEM;
clisten->cdev = cdev;
clisten->sk = sk;
mutex_lock(&notify_mutex); mutex_lock(&notify_mutex);
err = raw_notifier_call_chain(&listen_notify_list, err = raw_notifier_call_chain(&listen_notify_list,
CHTLS_LISTEN_START, sk); CHTLS_LISTEN_START, clisten);
mutex_unlock(&notify_mutex); mutex_unlock(&notify_mutex);
return err; return err;
} }
static void chtls_stop_listen(struct sock *sk) static void chtls_stop_listen(struct chtls_dev *cdev, struct sock *sk)
{ {
struct chtls_listen *clisten;
if (sk->sk_protocol != IPPROTO_TCP) if (sk->sk_protocol != IPPROTO_TCP)
return; return;
clisten = kmalloc(sizeof(*clisten), GFP_KERNEL);
if (!clisten)
return;
clisten->cdev = cdev;
clisten->sk = sk;
mutex_lock(&notify_mutex); mutex_lock(&notify_mutex);
raw_notifier_call_chain(&listen_notify_list, raw_notifier_call_chain(&listen_notify_list,
CHTLS_LISTEN_STOP, sk); CHTLS_LISTEN_STOP, clisten);
mutex_unlock(&notify_mutex); mutex_unlock(&notify_mutex);
} }
@ -138,15 +146,19 @@ static int chtls_inline_feature(struct tls_device *dev)
static int chtls_create_hash(struct tls_device *dev, struct sock *sk) static int chtls_create_hash(struct tls_device *dev, struct sock *sk)
{ {
struct chtls_dev *cdev = to_chtls_dev(dev);
if (sk->sk_state == TCP_LISTEN) if (sk->sk_state == TCP_LISTEN)
return chtls_start_listen(sk); return chtls_start_listen(cdev, sk);
return 0; return 0;
} }
static void chtls_destroy_hash(struct tls_device *dev, struct sock *sk) static void chtls_destroy_hash(struct tls_device *dev, struct sock *sk)
{ {
struct chtls_dev *cdev = to_chtls_dev(dev);
if (sk->sk_state == TCP_LISTEN) if (sk->sk_state == TCP_LISTEN)
chtls_stop_listen(sk); chtls_stop_listen(cdev, sk);
} }
static void chtls_free_uld(struct chtls_dev *cdev) static void chtls_free_uld(struct chtls_dev *cdev)