[PATCH v3] pvcalls-front: Avoid __get_free_pages(GFP_KERNEL) under spinlock

[PATCH v3] pvcalls-front: Avoid __get_free_pages(GFP_KERNEL) under spinlock

[Wen Yang]

The problem is that we call this with a spin lock held.
The call tree is:
pvcalls_front_accept() holds bedata->socket_lock.
    -> create_active()
        -> __get_free_pages() uses GFP_KERNEL

The create_active() function is only called from pvcalls_front_accept()
with a spin_lock held, The allocation is not allowed to sleep and
GFP_KERNEL is not sufficient.

This issue was detected by using the Coccinelle software.

v2: Add a function doing the allocations which is called
    outside the lock and passing the allocated data to
    create_active().
v3: Use the matching deallocators i.e., free_page()
    and free_pages(), respectively.

Suggested-by: Juergen Gross <jgross@suse.com>
Signed-off-by: Wen Yang <wen.yang99@zte.com.cn>
CC: Julia Lawall <julia.lawall@lip6.fr>
CC: Boris Ostrovsky <boris.ostrovsky@oracle.com>
CC: Juergen Gross <jgross@suse.com>
CC: Stefano Stabellini <sstabellini@kernel.org>
CC: xen-devel@lists.xenproject.org
CC: linux-kernel@vger.kernel.org
---
 drivers/xen/pvcalls-front.c | 71 ++++++++++++++++++++++++++++++-------
 1 file changed, 59 insertions(+), 12 deletions(-)

diff --git a/drivers/xen/pvcalls-front.c b/drivers/xen/pvcalls-front.c
index 2f11ca72a281..a26f416daf46 100644
--- a/drivers/xen/pvcalls-front.c
+++ b/drivers/xen/pvcalls-front.c
@@ -335,7 +335,43 @@ int pvcalls_front_socket(struct socket *sock)
 	return ret;
 }
 
-static int create_active(struct sock_mapping *map, int *evtchn)
+struct sock_mapping_active_ring {
+	struct pvcalls_data_intf *ring;
+	RING_IDX ring_order;
+	void *bytes;
+};
+
+static int alloc_active_ring(struct sock_mapping_active_ring *active_ring)
+{
+	active_ring->ring = NULL;
+	active_ring->bytes = NULL;
+
+	active_ring->ring = (struct pvcalls_data_intf *)
+		__get_free_page(GFP_KERNEL | __GFP_ZERO);
+	if (active_ring->ring == NULL)
+		goto out_error;
+	active_ring->ring_order = PVCALLS_RING_ORDER;
+	active_ring->bytes = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
+			PVCALLS_RING_ORDER);
+	if (active_ring->bytes == NULL)
+		goto out_error;
+
+	return 0;
+
+out_error:
+	free_pages((unsigned long)active_ring->bytes, active_ring->ring_order);
+	free_page((unsigned long)active_ring->ring);
+	return -ENOMEM;
+}
+
+static void free_active_ring(struct sock_mapping_active_ring *active_ring)
+{
+	free_pages((unsigned long)active_ring->bytes, active_ring->ring_order);
+	free_page((unsigned long)active_ring->ring);
+}
+
+static int create_active(struct sock_mapping *map, int *evtchn,
+		struct sock_mapping_active_ring *active_ring)
 {
 	void *bytes;
 	int ret = -ENOMEM, irq = -1, i;
@@ -343,15 +379,9 @@ static int create_active(struct sock_mapping *map, int *evtchn)
 	*evtchn = -1;
 	init_waitqueue_head(&map->active.inflight_conn_req);
 
-	map->active.ring = (struct pvcalls_data_intf *)
-		__get_free_page(GFP_KERNEL | __GFP_ZERO);
-	if (map->active.ring == NULL)
-		goto out_error;
-	map->active.ring->ring_order = PVCALLS_RING_ORDER;
-	bytes = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
-					PVCALLS_RING_ORDER);
-	if (bytes == NULL)
-		goto out_error;
+	map->active.ring = active_ring->ring;
+	map->active.ring->ring_order = active_ring->ring_order;
+	bytes = active_ring->bytes;
 	for (i = 0; i < (1 << PVCALLS_RING_ORDER); i++)
 		map->active.ring->ref[i] = gnttab_grant_foreign_access(
 			pvcalls_front_dev->otherend_id,
@@ -397,6 +427,7 @@ int pvcalls_front_connect(struct socket *sock, struct sockaddr *addr,
 	struct sock_mapping *map = NULL;
 	struct xen_pvcalls_request *req;
 	int notify, req_id, ret, evtchn;
+	struct sock_mapping_active_ring active_ring;
 
 	if (addr->sa_family != AF_INET || sock->type != SOCK_STREAM)
 		return -EOPNOTSUPP;
@@ -406,15 +437,21 @@ int pvcalls_front_connect(struct socket *sock, struct sockaddr *addr,
 		return PTR_ERR(map);
 
 	bedata = dev_get_drvdata(&pvcalls_front_dev->dev);
+	ret = alloc_active_ring(&active_ring);
+	if (ret < 0) {
+		pvcalls_exit_sock(sock);
+		return ret;
+	}
 
 	spin_lock(&bedata->socket_lock);
 	ret = get_request(bedata, &req_id);
 	if (ret < 0) {
 		spin_unlock(&bedata->socket_lock);
+		free_active_ring(&active_ring);
 		pvcalls_exit_sock(sock);
 		return ret;
 	}
-	ret = create_active(map, &evtchn);
+	ret = create_active(map, &evtchn, &active_ring);
 	if (ret < 0) {
 		spin_unlock(&bedata->socket_lock);
 		pvcalls_exit_sock(sock);
@@ -744,6 +781,7 @@ int pvcalls_front_accept(struct socket *sock, struct socket *newsock, int flags)
 	struct sock_mapping *map2 = NULL;
 	struct xen_pvcalls_request *req;
 	int notify, req_id, ret, evtchn, nonblock;
+	struct sock_mapping_active_ring active_ring;
 
 	map = pvcalls_enter_sock(sock);
 	if (IS_ERR(map))
@@ -780,12 +818,20 @@ int pvcalls_front_accept(struct socket *sock, struct socket *newsock, int flags)
 		}
 	}
 
+	ret = alloc_active_ring(&active_ring);
+	if (ret < 0) {
+		clear_bit(PVCALLS_FLAG_ACCEPT_INFLIGHT,
+				(void *)&map->passive.flags);
+		pvcalls_exit_sock(sock);
+		return ret;
+	}
 	spin_lock(&bedata->socket_lock);
 	ret = get_request(bedata, &req_id);
 	if (ret < 0) {
 		clear_bit(PVCALLS_FLAG_ACCEPT_INFLIGHT,
 			  (void *)&map->passive.flags);
 		spin_unlock(&bedata->socket_lock);
+		free_active_ring(&active_ring);
 		pvcalls_exit_sock(sock);
 		return ret;
 	}
@@ -794,10 +840,11 @@ int pvcalls_front_accept(struct socket *sock, struct socket *newsock, int flags)
 		clear_bit(PVCALLS_FLAG_ACCEPT_INFLIGHT,
 			  (void *)&map->passive.flags);
 		spin_unlock(&bedata->socket_lock);
+		free_active_ring(&active_ring);
 		pvcalls_exit_sock(sock);
 		return -ENOMEM;
 	}
-	ret = create_active(map2, &evtchn);
+	ret = create_active(map2, &evtchn, &active_ring);
 	if (ret < 0) {
 		kfree(map2);
 		clear_bit(PVCALLS_FLAG_ACCEPT_INFLIGHT,
-- 
2.19.1

Re: [PATCH v3] pvcalls-front: Avoid __get_free_pages(GFP_KERNEL) under spinlock

[Juergen Gross]

On 30/11/2018 12:01, Wen Yang wrote:
> The problem is that we call this with a spin lock held.
> The call tree is:
> pvcalls_front_accept() holds bedata->socket_lock.
>     -> create_active()
>         -> __get_free_pages() uses GFP_KERNEL
> 
> The create_active() function is only called from pvcalls_front_accept()
> with a spin_lock held, The allocation is not allowed to sleep and
> GFP_KERNEL is not sufficient.
> 
> This issue was detected by using the Coccinelle software.
> 
> v2: Add a function doing the allocations which is called
>     outside the lock and passing the allocated data to
>     create_active().
> v3: Use the matching deallocators i.e., free_page()
>     and free_pages(), respectively.
> 
> Suggested-by: Juergen Gross <jgross@suse.com>
> Signed-off-by: Wen Yang <wen.yang99@zte.com.cn>
> CC: Julia Lawall <julia.lawall@lip6.fr>
> CC: Boris Ostrovsky <boris.ostrovsky@oracle.com>
> CC: Juergen Gross <jgross@suse.com>
> CC: Stefano Stabellini <sstabellini@kernel.org>
> CC: xen-devel@lists.xenproject.org
> CC: linux-kernel@vger.kernel.org
> ---

This patch is malformed. Please send it via an appropriate tool/mailer.

See e.g. Documentation/process/submitting-patches.rst or
Documentation/process/email-clients.rst in the Linux kernel source tree.


Juergen

Re: [PATCH v3] pvcalls-front: Avoid __get_free_pages(GFP_KERNEL) under spinlock

[Boris Ostrovsky]

On 11/30/18 6:01 AM, Wen Yang wrote:
> The problem is that we call this with a spin lock held.
> The call tree is:
> pvcalls_front_accept() holds bedata->socket_lock.
>     -> create_active()
>         -> __get_free_pages() uses GFP_KERNEL
>
> The create_active() function is only called from pvcalls_front_accept()
> with a spin_lock held, The allocation is not allowed to sleep and
> GFP_KERNEL is not sufficient.
>
> This issue was detected by using the Coccinelle software.
>
> v2: Add a function doing the allocations which is called
>     outside the lock and passing the allocated data to
>     create_active().
> v3: Use the matching deallocators i.e., free_page()
>     and free_pages(), respectively.
>
> Suggested-by: Juergen Gross <jgross@suse.com>
> Signed-off-by: Wen Yang <wen.yang99@zte.com.cn>
> CC: Julia Lawall <julia.lawall@lip6.fr>
> CC: Boris Ostrovsky <boris.ostrovsky@oracle.com>
> CC: Juergen Gross <jgross@suse.com>
> CC: Stefano Stabellini <sstabellini@kernel.org>
> CC: xen-devel@lists.xenproject.org
> CC: linux-kernel@vger.kernel.org
> ---
>  drivers/xen/pvcalls-front.c | 71 ++++++++++++++++++++++++++++++-------
>  1 file changed, 59 insertions(+), 12 deletions(-)
>
> diff --git a/drivers/xen/pvcalls-front.c b/drivers/xen/pvcalls-front.c
> index 2f11ca72a281..a26f416daf46 100644
> --- a/drivers/xen/pvcalls-front.c
> +++ b/drivers/xen/pvcalls-front.c
> @@ -335,7 +335,43 @@ int pvcalls_front_socket(struct socket *sock)
>  	return ret;
>  }
>  
> -static int create_active(struct sock_mapping *map, int *evtchn)
> +struct sock_mapping_active_ring {
> +	struct pvcalls_data_intf *ring;
> +	RING_IDX ring_order;
> +	void *bytes;
> +};
> +
> +static int alloc_active_ring(struct sock_mapping_active_ring *active_ring)
> +{
> +	active_ring->ring = NULL;

This is not necessary.

> +	active_ring->bytes = NULL;
> +
> +	active_ring->ring = (struct pvcalls_data_intf *)
> +		__get_free_page(GFP_KERNEL | __GFP_ZERO);
> +	if (active_ring->ring == NULL)
> +		goto out_error;
> +	active_ring->ring_order = PVCALLS_RING_ORDER;
> +	active_ring->bytes = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
> +			PVCALLS_RING_ORDER);
> +	if (active_ring->bytes == NULL)
> +		goto out_error;
> +
> +	return 0;
> +
> +out_error:
> +	free_pages((unsigned long)active_ring->bytes, active_ring->ring_order);
> +	free_page((unsigned long)active_ring->ring);
> +	return -ENOMEM;
> +}
> +



> @@ -397,6 +427,7 @@ int pvcalls_front_connect(struct socket *sock, struct sockaddr *addr,
>  	struct sock_mapping *map = NULL;
>  	struct xen_pvcalls_request *req;
>  	int notify, req_id, ret, evtchn;
> +	struct sock_mapping_active_ring active_ring;
>  
>  	if (addr->sa_family != AF_INET || sock->type != SOCK_STREAM)
>  		return -EOPNOTSUPP;
> @@ -406,15 +437,21 @@ int pvcalls_front_connect(struct socket *sock, struct sockaddr *addr,
>  		return PTR_ERR(map);
>  
>  	bedata = dev_get_drvdata(&pvcalls_front_dev->dev);
> +	ret = alloc_active_ring(&active_ring);

Why not just alloc_active_ring(map)?


-boris

Re: [PATCH v3] pvcalls-front: Avoid __get_free_pages(GFP_KERNEL) under spinlock

[Stefano Stabellini]

On Fri, 30 Nov 2018, Boris Ostrovsky wrote:
> On 11/30/18 6:01 AM, Wen Yang wrote:
> > The problem is that we call this with a spin lock held.
> > The call tree is:
> > pvcalls_front_accept() holds bedata->socket_lock.
> >     -> create_active()
> >         -> __get_free_pages() uses GFP_KERNEL
> >
> > The create_active() function is only called from pvcalls_front_accept()
> > with a spin_lock held, The allocation is not allowed to sleep and
> > GFP_KERNEL is not sufficient.
> >
> > This issue was detected by using the Coccinelle software.
> >
> > v2: Add a function doing the allocations which is called
> >     outside the lock and passing the allocated data to
> >     create_active().
> > v3: Use the matching deallocators i.e., free_page()
> >     and free_pages(), respectively.
> >
> > Suggested-by: Juergen Gross <jgross@suse.com>
> > Signed-off-by: Wen Yang <wen.yang99@zte.com.cn>
> > CC: Julia Lawall <julia.lawall@lip6.fr>
> > CC: Boris Ostrovsky <boris.ostrovsky@oracle.com>
> > CC: Juergen Gross <jgross@suse.com>
> > CC: Stefano Stabellini <sstabellini@kernel.org>
> > CC: xen-devel@lists.xenproject.org
> > CC: linux-kernel@vger.kernel.org
> > ---
> >  drivers/xen/pvcalls-front.c | 71 ++++++++++++++++++++++++++++++-------
> >  1 file changed, 59 insertions(+), 12 deletions(-)
> >
> > diff --git a/drivers/xen/pvcalls-front.c b/drivers/xen/pvcalls-front.c
> > index 2f11ca72a281..a26f416daf46 100644
> > --- a/drivers/xen/pvcalls-front.c
> > +++ b/drivers/xen/pvcalls-front.c
> > @@ -335,7 +335,43 @@ int pvcalls_front_socket(struct socket *sock)
> >  	return ret;
> >  }
> >  
> > -static int create_active(struct sock_mapping *map, int *evtchn)
> > +struct sock_mapping_active_ring {
> > +	struct pvcalls_data_intf *ring;
> > +	RING_IDX ring_order;
> > +	void *bytes;
> > +};
> > +
> > +static int alloc_active_ring(struct sock_mapping_active_ring *active_ring)
> > +{
> > +	active_ring->ring = NULL;
> 
> This is not necessary.
> 
> > +	active_ring->bytes = NULL;
> > +
> > +	active_ring->ring = (struct pvcalls_data_intf *)
> > +		__get_free_page(GFP_KERNEL | __GFP_ZERO);
> > +	if (active_ring->ring == NULL)
> > +		goto out_error;
> > +	active_ring->ring_order = PVCALLS_RING_ORDER;
> > +	active_ring->bytes = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
> > +			PVCALLS_RING_ORDER);
> > +	if (active_ring->bytes == NULL)
> > +		goto out_error;
> > +
> > +	return 0;
> > +
> > +out_error:
> > +	free_pages((unsigned long)active_ring->bytes, active_ring->ring_order);
> > +	free_page((unsigned long)active_ring->ring);
> > +	return -ENOMEM;
> > +}
> > +
> 
> 
> 
> > @@ -397,6 +427,7 @@ int pvcalls_front_connect(struct socket *sock, struct sockaddr *addr,
> >  	struct sock_mapping *map = NULL;
> >  	struct xen_pvcalls_request *req;
> >  	int notify, req_id, ret, evtchn;
> > +	struct sock_mapping_active_ring active_ring;
> >  
> >  	if (addr->sa_family != AF_INET || sock->type != SOCK_STREAM)
> >  		return -EOPNOTSUPP;
> > @@ -406,15 +437,21 @@ int pvcalls_front_connect(struct socket *sock, struct sockaddr *addr,
> >  		return PTR_ERR(map);
> >  
> >  	bedata = dev_get_drvdata(&pvcalls_front_dev->dev);
> > +	ret = alloc_active_ring(&active_ring);
> 
> Why not just alloc_active_ring(map)?

Yes, I think it would be better to pre-populate map (struct
sock_mapping), rather than introducing one more new struct (struct
sock_mapping_active_ring).