rxrpc: Pass struct socket * to more rxrpc kernel interface functions (4de48af6) · Commits · e / devices / android_kernel_fairphone_FP4

Documentation/networking/rxrpc.txt

+8 −3

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

	(*) End a client call.		(*) 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		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		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.		(*) 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);		size_t len);

	This is used to supply either the request part of a client call or the		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.		(*) 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		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.		abort code specified will be placed in the ABORT message sent.

fs/afs/rxrpc.c

+15 −11

Original line number	Original line	Diff line number	Diff line
	@@ -207,7 +207,7 @@ static void afs_free_call(struct afs_call *call)
	static void afs_end_call_nofree(struct afs_call *call)		static void afs_end_call_nofree(struct afs_call *call)
	{		{
	if (call->rxcall) {		if (call->rxcall) {
	rxrpc_kernel_end_call(call->rxcall);		rxrpc_kernel_end_call(afs_socket, call->rxcall);
	call->rxcall = NULL;		call->rxcall = NULL;
	}		}
	if (call->type->destructor)		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 */		* returns from sending the request */
	if (first + loop >= last)		if (first + loop >= last)
	call->state = AFS_CALL_AWAIT_REPLY;		call->state = AFS_CALL_AWAIT_REPLY;
	ret = rxrpc_kernel_send_data(call->rxcall, msg,		ret = rxrpc_kernel_send_data(afs_socket, call->rxcall,
	to - offset);		msg, to - offset);
	kunmap(pages[loop]);		kunmap(pages[loop]);
	if (ret < 0)		if (ret < 0)
	break;		break;
	@@ -406,7 +406,8 @@ int afs_make_call(struct in_addr addr, struct afs_call call, gfp_t gfp,
	* request */		* request */
	if (!call->send_pages)		if (!call->send_pages)
	call->state = AFS_CALL_AWAIT_REPLY;		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)		if (ret < 0)
	goto error_do_abort;		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);		return wait_mode->wait(call);

	error_do_abort:		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)))		while ((skb = skb_dequeue(&call->rx_queue)))
	afs_free_skb(skb);		afs_free_skb(skb);
	error_kill_call:		error_kill_call:
	@@ -509,7 +510,8 @@ static void afs_deliver_to_call(struct afs_call *call)
	if (call->state != AFS_CALL_AWAIT_REPLY)		if (call->state != AFS_CALL_AWAIT_REPLY)
	abort_code = RXGEN_SS_UNMARSHAL;		abort_code = RXGEN_SS_UNMARSHAL;
	do_abort:		do_abort:
	rxrpc_kernel_abort_call(call->rxcall,		rxrpc_kernel_abort_call(afs_socket,
			call->rxcall,
	abort_code);		abort_code);
	call->error = ret;		call->error = ret;
	call->state = AFS_CALL_ERROR;		call->state = AFS_CALL_ERROR;
	@@ -605,7 +607,7 @@ static int afs_wait_for_call_to_complete(struct afs_call *call)
	/* kill the call */		/* kill the call */
	if (call->state < AFS_CALL_COMPLETE) {		if (call->state < AFS_CALL_COMPLETE) {
	_debug("call incomplete");		_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)))		while ((skb = skb_dequeue(&call->rx_queue)))
	afs_free_skb(skb);		afs_free_skb(skb);
	}		}
	@@ -823,14 +825,15 @@ void afs_send_empty_reply(struct afs_call *call)
	msg.msg_flags = 0;		msg.msg_flags = 0;

	call->state = AFS_CALL_AWAIT_ACK;		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:		case 0:
	_leave(" [replied]");		_leave(" [replied]");
	return;		return;

	case -ENOMEM:		case -ENOMEM:
	_debug("oom");		_debug("oom");
	rxrpc_kernel_abort_call(call->rxcall, RX_USER_ABORT);		rxrpc_kernel_abort_call(afs_socket, call->rxcall,
			RX_USER_ABORT);
	default:		default:
	afs_end_call(call);		afs_end_call(call);
	_leave(" [error]");		_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;		msg.msg_flags = 0;

	call->state = AFS_CALL_AWAIT_ACK;		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) {		if (n >= 0) {
	/* Success */		/* Success */
	_leave(" [replied]");		_leave(" [replied]");
	@@ -868,7 +871,8 @@ void afs_send_simple_reply(struct afs_call call, const void buf, size_t len)

	if (n == -ENOMEM) {		if (n == -ENOMEM) {
	_debug("oom");		_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);		afs_end_call(call);
	_leave(" [error]");		_leave(" [error]");

include/net/af_rxrpc.h

+7 −3

Original line number	Original line	Diff line number	Diff line
	@@ -15,6 +15,9 @@
	#include <linux/skbuff.h>		#include <linux/skbuff.h>
	#include <linux/rxrpc.h>		#include <linux/rxrpc.h>

			struct key;
			struct sock;
			struct socket;
	struct rxrpc_call;		struct rxrpc_call;

	/*		/*
	@@ -39,10 +42,11 @@ struct rxrpc_call rxrpc_kernel_begin_call(struct socket ,
	struct key *,		struct key *,
	unsigned long,		unsigned long,
	gfp_t);		gfp_t);
	int rxrpc_kernel_send_data(struct rxrpc_call , struct msghdr , size_t);		int rxrpc_kernel_send_data(struct socket , struct rxrpc_call ,
			struct msghdr *, size_t);
	void rxrpc_kernel_data_consumed(struct rxrpc_call , struct sk_buff );		void rxrpc_kernel_data_consumed(struct rxrpc_call , struct sk_buff );
	void rxrpc_kernel_abort_call(struct rxrpc_call *, u32);		void rxrpc_kernel_abort_call(struct socket , struct rxrpc_call , u32);
	void rxrpc_kernel_end_call(struct rxrpc_call *);		void rxrpc_kernel_end_call(struct socket , struct rxrpc_call );
	bool rxrpc_kernel_is_data_last(struct sk_buff *);		bool rxrpc_kernel_is_data_last(struct sk_buff *);
	u32 rxrpc_kernel_get_abort_code(struct sk_buff *);		u32 rxrpc_kernel_get_abort_code(struct sk_buff *);
	int rxrpc_kernel_get_error_number(struct sk_buff *);		int rxrpc_kernel_get_error_number(struct sk_buff *);

net/rxrpc/af_rxrpc.c

+3 −2

Original line number	Original line	Diff line number	Diff line
	@@ -279,15 +279,16 @@ EXPORT_SYMBOL(rxrpc_kernel_begin_call);

	/**		/**
	* rxrpc_kernel_end_call - Allow a kernel service to end a call it was using		* rxrpc_kernel_end_call - Allow a kernel service to end a call it was using
			* @sock: The socket the call is on
	* @call: The call to end		* @call: The call to end
	*		*
	* Allow a kernel service to end a call it was using. The call must be		* Allow a kernel service to end a call it was using. The call must be
	* complete before this is called (the call should be aborted if necessary).		* complete before this is called (the call should be aborted if necessary).
	*/		*/
	void rxrpc_kernel_end_call(struct rxrpc_call *call)		void rxrpc_kernel_end_call(struct socket sock, struct rxrpc_call call)
	{		{
	_enter("%d{%d}", call->debug_id, atomic_read(&call->usage));		_enter("%d{%d}", call->debug_id, atomic_read(&call->usage));
	rxrpc_remove_user_ID(call->socket, call);		rxrpc_remove_user_ID(rxrpc_sk(sock->sk), call);
	rxrpc_put_call(call);		rxrpc_put_call(call);
	}		}
	EXPORT_SYMBOL(rxrpc_kernel_end_call);		EXPORT_SYMBOL(rxrpc_kernel_end_call);

net/rxrpc/output.c

+11 −9

Original line number	Original line	Diff line number	Diff line
	@@ -239,6 +239,7 @@ int rxrpc_do_sendmsg(struct rxrpc_sock rx, struct msghdr msg, size_t len)

	/**		/**
	* rxrpc_kernel_send_data - Allow a kernel service to send data on a call		* rxrpc_kernel_send_data - Allow a kernel service to send data on a call
			* @sock: The socket the call is on
	* @call: The call to send data through		* @call: The call to send data through
	* @msg: The data to send		* @msg: The data to send
	* @len: The amount of data to send		* @len: The amount of data to send
	@@ -248,8 +249,8 @@ int rxrpc_do_sendmsg(struct rxrpc_sock rx, struct msghdr msg, size_t len)
	* nor should an address be supplied. MSG_MORE should be flagged if there's		* nor should an address be supplied. MSG_MORE should be flagged if there's
	* more data to come, otherwise this data will end the transmission phase.		* more data to come, otherwise this data will end the transmission phase.
	*/		*/
	int rxrpc_kernel_send_data(struct rxrpc_call call, struct msghdr msg,		int rxrpc_kernel_send_data(struct socket sock, struct rxrpc_call call,
	size_t len)		struct msghdr *msg, size_t len)
	{		{
	int ret;		int ret;

	@@ -258,7 +259,7 @@ int rxrpc_kernel_send_data(struct rxrpc_call call, struct msghdr msg,
	ASSERTCMP(msg->msg_name, ==, NULL);		ASSERTCMP(msg->msg_name, ==, NULL);
	ASSERTCMP(msg->msg_control, ==, NULL);		ASSERTCMP(msg->msg_control, ==, NULL);

	lock_sock(&call->socket->sk);		lock_sock(sock->sk);

	_debug("CALL %d USR %lx ST %d on CONN %p",		_debug("CALL %d USR %lx ST %d on CONN %p",
	call->debug_id, call->user_call_ID, call->state, call->conn);		call->debug_id, call->user_call_ID, call->state, call->conn);
	@@ -270,35 +271,36 @@ int rxrpc_kernel_send_data(struct rxrpc_call call, struct msghdr msg,
	call->state != RXRPC_CALL_SERVER_SEND_REPLY) {		call->state != RXRPC_CALL_SERVER_SEND_REPLY) {
	ret = -EPROTO; /* request phase complete for this client call */		ret = -EPROTO; /* request phase complete for this client call */
	} else {		} else {
	ret = rxrpc_send_data(call->socket, call, msg, len);		ret = rxrpc_send_data(rxrpc_sk(sock->sk), call, msg, len);
	}		}

	release_sock(&call->socket->sk);		release_sock(sock->sk);
	_leave(" = %d", ret);		_leave(" = %d", ret);
	return ret;		return ret;
	}		}

	EXPORT_SYMBOL(rxrpc_kernel_send_data);		EXPORT_SYMBOL(rxrpc_kernel_send_data);

	/**		/**
	* rxrpc_kernel_abort_call - Allow a kernel service to abort a call		* rxrpc_kernel_abort_call - Allow a kernel service to abort a call
			* @sock: The socket the call is on
	* @call: The call to be aborted		* @call: The call to be aborted
	* @abort_code: The abort code to stick into the ABORT packet		* @abort_code: The abort code to stick into the ABORT packet
	*		*
	* Allow a kernel service to abort a call, if it's still in an abortable state.		* Allow a kernel service to abort a call, if it's still in an abortable state.
	*/		*/
	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)
	{		{
	_enter("{%d},%d", call->debug_id, abort_code);		_enter("{%d},%d", call->debug_id, abort_code);

	lock_sock(&call->socket->sk);		lock_sock(sock->sk);

	_debug("CALL %d USR %lx ST %d on CONN %p",		_debug("CALL %d USR %lx ST %d on CONN %p",
	call->debug_id, call->user_call_ID, call->state, call->conn);		call->debug_id, call->user_call_ID, call->state, call->conn);

	rxrpc_send_abort(call, abort_code);		rxrpc_send_abort(call, abort_code);

	release_sock(&call->socket->sk);		release_sock(sock->sk);
	_leave("");		_leave("");
	}		}