Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 792438e5 authored by David S. Miller's avatar David S. Miller
Browse files

Merge tag 'rxrpc-rewrite-20160830-1' of... 

Merge tag 'rxrpc-rewrite-20160830-1' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs



David Howells says:

====================
rxrpc: Preparation for removal of use of skbs from AFS

Here's a set of patches that prepare the way for the removal of the use of
sk_buffs from fs/afs (they'll be entirely retained within net/rxrpc):

 (1) Fix a potential NULL-pointer deref in rxrpc_abort_calls().

 (2) Condense all the terminal call state machine states to a single one
     plus supplementary info.

 (3) Add a trace point for rxrpc call usage debugging.

 (4) Cleanups and missing headers.

 (5) Provide a way for AFS to ask about a call's peer address without
     having an sk_buff to query.

 (6) Use call->peer directly rather than going via call->conn (which might
     be NULL).

 (7) Pass struct socket * to various rxrpc kernel interface functions so
     they can use that directly rather than getting it from the rxrpc_call
     struct.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents cf4d13fe 4de48af6

Documentation/networking/rxrpc.txt

+15 −3
Original line number Diff line number Diff line
@@ -725,7 +725,8 @@ The kernel interface functions are as follows: 


 (*) End a client call.



	void rxrpc_kernel_end_call(struct rxrpc_call *call);

	void rxrpc_kernel_end_call(struct socket *sock,

				   struct rxrpc_call *call);



     This is used to end a previously begun call.  The user_call_ID is expunged

     from AF_RXRPC's knowledge and will not be seen again in association with
@@ -733,7 +734,9 @@ The kernel interface functions are as follows: 


 (*) Send data through a call.



	int rxrpc_kernel_send_data(struct rxrpc_call *call, struct msghdr *msg,

	int rxrpc_kernel_send_data(struct socket *sock,

				   struct rxrpc_call *call,

				   struct msghdr *msg,

				   size_t len);



     This is used to supply either the request part of a client call or the
@@ -747,7 +750,9 @@ The kernel interface functions are as follows: 


 (*) Abort a call.



	void rxrpc_kernel_abort_call(struct rxrpc_call *call, u32 abort_code);

	void rxrpc_kernel_abort_call(struct socket *sock,

				     struct rxrpc_call *call,

				     u32 abort_code);



     This is used to abort a call if it's still in an abortable state.  The

     abort code specified will be placed in the ABORT message sent.
@@ -868,6 +873,13 @@ The kernel interface functions are as follows: 
     This is used to allocate a null RxRPC key that can be used to indicate

     anonymous security for a particular domain.



 (*) Get the peer address of a call.



	void rxrpc_kernel_get_peer(struct socket *sock, struct rxrpc_call *call,

				   struct sockaddr_rxrpc *_srx);



     This is used to find the remote peer address of a call.





=======================

CONFIGURABLE PARAMETERS

fs/afs/cmservice.c

+11 −15
Original line number Diff line number Diff line
@@ -17,10 +17,6 @@ 
#include "internal.h"

#include "afs_cm.h"



#if 0

struct workqueue_struct *afs_cm_workqueue;

#endif  /*  0  */



static int afs_deliver_cb_init_call_back_state(struct afs_call *,

					       struct sk_buff *, bool);

static int afs_deliver_cb_init_call_back_state3(struct afs_call *,
@@ -171,9 +167,9 @@ static void SRXAFSCB_CallBack(struct work_struct *work) 
static int afs_deliver_cb_callback(struct afs_call *call, struct sk_buff *skb,

				   bool last)

{

	struct sockaddr_rxrpc srx;

	struct afs_callback *cb;

	struct afs_server *server;

	struct in_addr addr;

	__be32 *bp;

	u32 tmp;

	int ret, loop;
@@ -182,6 +178,7 @@ static int afs_deliver_cb_callback(struct afs_call *call, struct sk_buff *skb, 


	switch (call->unmarshall) {

	case 0:

		rxrpc_kernel_get_peer(afs_socket, call->rxcall, &srx);

		call->offset = 0;

		call->unmarshall++;
@@ -282,13 +279,11 @@ static int afs_deliver_cb_callback(struct afs_call *call, struct sk_buff *skb, 
		break;

	}





	call->state = AFS_CALL_REPLYING;



	/* we'll need the file server record as that tells us which set of

	 * vnodes to operate upon */

	memcpy(&addr, &ip_hdr(skb)->saddr, 4);

	server = afs_find_server(&addr);

	server = afs_find_server(&srx);

	if (!server)

		return -ENOTCONN;

	call->server = server;
@@ -319,12 +314,14 @@ static int afs_deliver_cb_init_call_back_state(struct afs_call *call, 
					       struct sk_buff *skb,

					       bool last)

{

	struct sockaddr_rxrpc srx;

	struct afs_server *server;

	struct in_addr addr;

	int ret;



	_enter(",{%u},%d", skb->len, last);



	rxrpc_kernel_get_peer(afs_socket, call->rxcall, &srx);



	ret = afs_data_complete(call, skb, last);

	if (ret < 0)

		return ret;
@@ -334,8 +331,7 @@ static int afs_deliver_cb_init_call_back_state(struct afs_call *call, 


	/* we'll need the file server record as that tells us which set of

	 * vnodes to operate upon */

	memcpy(&addr, &ip_hdr(skb)->saddr, 4);

	server = afs_find_server(&addr);

	server = afs_find_server(&srx);

	if (!server)

		return -ENOTCONN;

	call->server = server;
@@ -352,11 +348,13 @@ static int afs_deliver_cb_init_call_back_state3(struct afs_call *call, 
						struct sk_buff *skb,

						bool last)

{

	struct sockaddr_rxrpc srx;

	struct afs_server *server;

	struct in_addr addr;



	_enter(",{%u},%d", skb->len, last);



	rxrpc_kernel_get_peer(afs_socket, call->rxcall, &srx);



	/* There are some arguments that we ignore */

	afs_data_consumed(call, skb);

	if (!last)
@@ -367,8 +365,7 @@ static int afs_deliver_cb_init_call_back_state3(struct afs_call *call, 


	/* we'll need the file server record as that tells us which set of

	 * vnodes to operate upon */

	memcpy(&addr, &ip_hdr(skb)->saddr, 4);

	server = afs_find_server(&addr);

	server = afs_find_server(&srx);

	if (!server)

		return -ENOTCONN;

	call->server = server;
@@ -426,7 +423,6 @@ static void SRXAFSCB_ProbeUuid(struct work_struct *work) 


	_enter("");





	if (memcmp(r, &afs_uuid, sizeof(afs_uuid)) == 0)

		reply.match = htonl(0);

	else

fs/afs/internal.h

+4 −1
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ 
#include <linux/sched.h>

#include <linux/fscache.h>

#include <linux/backing-dev.h>

#include <net/af_rxrpc.h>



#include "afs.h"

#include "afs_vl.h"
@@ -607,6 +608,8 @@ extern void afs_proc_cell_remove(struct afs_cell *); 
/*

 * rxrpc.c

 */

extern struct socket *afs_socket;



extern int afs_open_socket(void);

extern void afs_close_socket(void);

extern void afs_data_consumed(struct afs_call *, struct sk_buff *);
@@ -654,7 +657,7 @@ do { \ 


extern struct afs_server *afs_lookup_server(struct afs_cell *,

					    const struct in_addr *);

extern struct afs_server *afs_find_server(const struct in_addr *);

extern struct afs_server *afs_find_server(const struct sockaddr_rxrpc *);

extern void afs_put_server(struct afs_server *);

extern void __exit afs_purge_servers(void);

fs/afs/main.c

+1 −0
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ 
#include <linux/init.h>

#include <linux/completion.h>

#include <linux/sched.h>

#include <linux/random.h>

#include "internal.h"



MODULE_DESCRIPTION("AFS Client File System");

fs/afs/rxrpc.c

+16 −12
Original line number Diff line number Diff line
@@ -16,7 +16,7 @@ 
#include "internal.h"

#include "afs_cm.h"



static struct socket *afs_socket; /* my RxRPC socket */

struct socket *afs_socket; /* my RxRPC socket */

static struct workqueue_struct *afs_async_calls;

static atomic_t afs_outstanding_calls;

static atomic_t afs_outstanding_skbs;
@@ -207,7 +207,7 @@ static void afs_free_call(struct afs_call *call) 
static void afs_end_call_nofree(struct afs_call *call)

{

	if (call->rxcall) {

		rxrpc_kernel_end_call(call->rxcall);

		rxrpc_kernel_end_call(afs_socket, call->rxcall);

		call->rxcall = NULL;

	}

	if (call->type->destructor)
@@ -325,8 +325,8 @@ static int afs_send_pages(struct afs_call *call, struct msghdr *msg, 
			 * returns from sending the request */

			if (first + loop >= last)

				call->state = AFS_CALL_AWAIT_REPLY;

			ret = rxrpc_kernel_send_data(call->rxcall, msg,

						     to - offset);

			ret = rxrpc_kernel_send_data(afs_socket, call->rxcall,

						     msg, to - offset);

			kunmap(pages[loop]);

			if (ret < 0)

				break;
@@ -406,7 +406,8 @@ int afs_make_call(struct in_addr *addr, struct afs_call *call, gfp_t gfp, 
	 * request */

	if (!call->send_pages)

		call->state = AFS_CALL_AWAIT_REPLY;

	ret = rxrpc_kernel_send_data(rxcall, &msg, call->request_size);

	ret = rxrpc_kernel_send_data(afs_socket, rxcall,

				     &msg, call->request_size);

	if (ret < 0)

		goto error_do_abort;
@@ -421,7 +422,7 @@ int afs_make_call(struct in_addr *addr, struct afs_call *call, gfp_t gfp, 
	return wait_mode->wait(call);



error_do_abort:

	rxrpc_kernel_abort_call(rxcall, RX_USER_ABORT);

	rxrpc_kernel_abort_call(afs_socket, rxcall, RX_USER_ABORT);

	while ((skb = skb_dequeue(&call->rx_queue)))

		afs_free_skb(skb);

error_kill_call:
@@ -509,7 +510,8 @@ static void afs_deliver_to_call(struct afs_call *call) 
				if (call->state != AFS_CALL_AWAIT_REPLY)

					abort_code = RXGEN_SS_UNMARSHAL;

			do_abort:

				rxrpc_kernel_abort_call(call->rxcall,

				rxrpc_kernel_abort_call(afs_socket,

							call->rxcall,

							abort_code);

				call->error = ret;

				call->state = AFS_CALL_ERROR;
@@ -605,7 +607,7 @@ static int afs_wait_for_call_to_complete(struct afs_call *call) 
	/* kill the call */

	if (call->state < AFS_CALL_COMPLETE) {

		_debug("call incomplete");

		rxrpc_kernel_abort_call(call->rxcall, RX_CALL_DEAD);

		rxrpc_kernel_abort_call(afs_socket, call->rxcall, RX_CALL_DEAD);

		while ((skb = skb_dequeue(&call->rx_queue)))

			afs_free_skb(skb);

	}
@@ -823,14 +825,15 @@ void afs_send_empty_reply(struct afs_call *call) 
	msg.msg_flags		= 0;



	call->state = AFS_CALL_AWAIT_ACK;

	switch (rxrpc_kernel_send_data(call->rxcall, &msg, 0)) {

	switch (rxrpc_kernel_send_data(afs_socket, call->rxcall, &msg, 0)) {

	case 0:

		_leave(" [replied]");

		return;



	case -ENOMEM:

		_debug("oom");

		rxrpc_kernel_abort_call(call->rxcall, RX_USER_ABORT);

		rxrpc_kernel_abort_call(afs_socket, call->rxcall,

					RX_USER_ABORT);

	default:

		afs_end_call(call);

		_leave(" [error]");
@@ -859,7 +862,7 @@ void afs_send_simple_reply(struct afs_call *call, const void *buf, size_t len) 
	msg.msg_flags		= 0;



	call->state = AFS_CALL_AWAIT_ACK;

	n = rxrpc_kernel_send_data(call->rxcall, &msg, len);

	n = rxrpc_kernel_send_data(afs_socket, call->rxcall, &msg, len);

	if (n >= 0) {

		/* Success */

		_leave(" [replied]");
@@ -868,7 +871,8 @@ void afs_send_simple_reply(struct afs_call *call, const void *buf, size_t len) 


	if (n == -ENOMEM) {

		_debug("oom");

		rxrpc_kernel_abort_call(call->rxcall, RX_USER_ABORT);

		rxrpc_kernel_abort_call(afs_socket, call->rxcall,

					RX_USER_ABORT);

	}

	afs_end_call(call);

	_leave(" [error]");