Merge tag 'rxrpc-next-20171018' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs (9854d758) · Commits · 戴 / test

Documentation/networking/rxrpc.txt

+51 −2

Original line number	Diff line number	Diff line
		@@ -280,6 +280,18 @@ Interaction with the user of the RxRPC socket:
		nominated by a socket option.


		Notes on sendmsg:

		(*) MSG_WAITALL can be set to tell sendmsg to ignore signals if the peer is
		making progress at accepting packets within a reasonable time such that we
		manage to queue up all the data for transmission. This requires the
		client to accept at least one packet per 2*RTT time period.

		If this isn't set, sendmsg() will return immediately, either returning
		EINTR/ERESTARTSYS if nothing was consumed or returning the amount of data
		consumed.


		Notes on recvmsg:

		(*) If there's a sequence of data messages belonging to a particular call on
		@@ -782,7 +794,9 @@ The kernel interface functions are as follows:
		struct key *key,
		unsigned long user_call_ID,
		s64 tx_total_len,
		gfp_t gfp);
		gfp_t gfp,
		rxrpc_notify_rx_t notify_rx,
		bool upgrade);

		This allocates the infrastructure to make a new RxRPC call and assigns
		call and connection numbers. The call will be made on the UDP port that
		@@ -803,6 +817,13 @@ The kernel interface functions are as follows:
		allows the kernel to encrypt directly to the packet buffers, thereby
		saving a copy. The value may not be less than -1.

		notify_rx is a pointer to a function to be called when events such as
		incoming data packets or remote aborts happen.

		upgrade should be set to true if a client operation should request that
		the server upgrade the service to a better one. The resultant service ID
		is returned by rxrpc_kernel_recv_data().

		If this function is successful, an opaque reference to the RxRPC call is
		returned. The caller now holds a reference on this and it must be
		properly ended.
		@@ -850,7 +871,8 @@ The kernel interface functions are as follows:
		size_t size,
		size_t *_offset,
		bool want_more,
		u32 *_abort)
		u32 *_abort,
		u16 *_service)

		This is used to receive data from either the reply part of a client call
		or the request part of a service call. buf and size specify how much
		@@ -873,6 +895,9 @@ The kernel interface functions are as follows:
		If a remote ABORT is detected, the abort code received will be stored in
		*_abort and ECONNABORTED will be returned.

		The service ID that the call ended up with is returned into *_service.
		This can be used to see if a call got a service upgrade.

		(*) Abort a call.

		void rxrpc_kernel_abort_call(struct socket *sock,
		@@ -1020,6 +1045,30 @@ The kernel interface functions are as follows:

		It returns 0 if the call was requeued and an error otherwise.

		(*) Get call RTT.

		u64 rxrpc_kernel_get_rtt(struct socket sock, struct rxrpc_call call);

		Get the RTT time to the peer in use by a call. The value returned is in
		nanoseconds.

		(*) Check call still alive.

		u32 rxrpc_kernel_check_life(struct socket *sock,
		struct rxrpc_call *call);

		This returns a number that is updated when ACKs are received from the peer
		(notably including PING RESPONSE ACKs which we can elicit by sending PING
		ACKs to see if the call still exists on the server). The caller should
		compare the numbers of two calls to see if the call is still alive after
		waiting for a suitable interval.

		This allows the caller to work out if the server is still contactable and
		if the call is still alive on the server whilst waiting for the server to
		process a client operation.

		This function may transmit a PING ACK.


		=======================
		CONFIGURABLE PARAMETERS

fs/afs/internal.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -100,6 +100,7 @@ struct afs_call {
		bool send_pages; /* T if data from mapping should be sent */
		bool need_attention; /* T if RxRPC poked us */
		bool async; /* T if asynchronous */
		bool upgrade; /* T to request service upgrade */
		u16 service_id; /* RxRPC service ID to call */
		__be16 port; /* target UDP port */
		u32 operation_ID; /* operation ID for an incoming call */

fs/afs/rxrpc.c

+33 −9

Original line number	Diff line number	Diff line
		@@ -387,7 +387,8 @@ int afs_make_call(struct in_addr addr, struct afs_call call, gfp_t gfp,
		tx_total_len, gfp,
		(async ?
		afs_wake_up_async_call :
		afs_wake_up_call_waiter));
		afs_wake_up_call_waiter),
		call->upgrade);
		call->key = NULL;
		if (IS_ERR(rxcall)) {
		ret = PTR_ERR(rxcall);
		@@ -406,7 +407,7 @@ int afs_make_call(struct in_addr addr, struct afs_call call, gfp_t gfp,
		call->request_size);
		msg.msg_control = NULL;
		msg.msg_controllen = 0;
		msg.msg_flags = (call->send_pages ? MSG_MORE : 0);
		msg.msg_flags = MSG_WAITALL \| (call->send_pages ? MSG_MORE : 0);

		/* We have to change the state before sending the last packet as
		* rxrpc might give us the reply before it returns from sending the
		@@ -443,7 +444,7 @@ error_do_abort:
		abort_code = 0;
		offset = 0;
		rxrpc_kernel_recv_data(afs_socket, rxcall, NULL, 0, &offset,
		false, &abort_code);
		false, &abort_code, &call->service_id);
		ret = call->type->abort_to_error(abort_code);
		}
		error_kill_call:
		@@ -471,7 +472,8 @@ static void afs_deliver_to_call(struct afs_call *call)
		size_t offset = 0;
		ret = rxrpc_kernel_recv_data(afs_socket, call->rxcall,
		NULL, 0, &offset, false,
		&call->abort_code);
		&call->abort_code,
		&call->service_id);
		trace_afs_recv_data(call, 0, offset, false, ret);

		if (ret == -EINPROGRESS \|\| ret == -EAGAIN)
		@@ -536,15 +538,26 @@ call_complete:
		*/
		static int afs_wait_for_call_to_complete(struct afs_call *call)
		{
		signed long rtt2, timeout;
		int ret;
		u64 rtt;
		u32 life, last_life;

		DECLARE_WAITQUEUE(myself, current);

		_enter("");

		rtt = rxrpc_kernel_get_rtt(afs_socket, call->rxcall);
		rtt2 = nsecs_to_jiffies64(rtt) * 2;
		if (rtt2 < 2)
		rtt2 = 2;

		timeout = rtt2;
		last_life = rxrpc_kernel_check_life(afs_socket, call->rxcall);

		add_wait_queue(&call->waitq, &myself);
		for (;;) {
		set_current_state(TASK_INTERRUPTIBLE);
		set_current_state(TASK_UNINTERRUPTIBLE);

		/* deliver any messages that are in the queue */
		if (call->state < AFS_CALL_COMPLETE && call->need_attention) {
		@@ -554,10 +567,20 @@ static int afs_wait_for_call_to_complete(struct afs_call *call)
		continue;
		}

		if (call->state == AFS_CALL_COMPLETE \|\|
		signal_pending(current))
		if (call->state == AFS_CALL_COMPLETE)
		break;
		schedule();

		life = rxrpc_kernel_check_life(afs_socket, call->rxcall);
		if (timeout == 0 &&
		life == last_life && signal_pending(current))
		break;

		if (life != last_life) {
		timeout = rtt2;
		last_life = life;
		}

		timeout = schedule_timeout(timeout);
		}

		remove_wait_queue(&call->waitq, &myself);
		@@ -851,7 +874,8 @@ int afs_extract_data(struct afs_call call, void buf, size_t count,

		ret = rxrpc_kernel_recv_data(afs_socket, call->rxcall,
		buf, count, &call->offset,
		want_more, &call->abort_code);
		want_more, &call->abort_code,
		&call->service_id);
		trace_afs_recv_data(call, count, call->offset, want_more, ret);
		if (ret == 0 \|\| ret == -EAGAIN)
		return ret;

include/net/af_rxrpc.h

+5 −2

Original line number	Diff line number	Diff line
		@@ -49,17 +49,19 @@ struct rxrpc_call rxrpc_kernel_begin_call(struct socket ,
		unsigned long,
		s64,
		gfp_t,
		rxrpc_notify_rx_t);
		rxrpc_notify_rx_t,
		bool);
		int rxrpc_kernel_send_data(struct socket , struct rxrpc_call ,
		struct msghdr *, size_t,
		rxrpc_notify_end_tx_t);
		int rxrpc_kernel_recv_data(struct socket , struct rxrpc_call ,
		void , size_t, size_t , bool, u32 *);
		void , size_t, size_t , bool, u32 , u16 );
		bool rxrpc_kernel_abort_call(struct socket , struct rxrpc_call ,
		u32, int, const char *);
		void rxrpc_kernel_end_call(struct socket , struct rxrpc_call );
		void rxrpc_kernel_get_peer(struct socket , struct rxrpc_call ,
		struct sockaddr_rxrpc *);
		u64 rxrpc_kernel_get_rtt(struct socket , struct rxrpc_call );
		int rxrpc_kernel_charge_accept(struct socket *, rxrpc_notify_rx_t,
		rxrpc_user_attach_call_t, unsigned long, gfp_t);
		void rxrpc_kernel_set_tx_length(struct socket , struct rxrpc_call , s64);
		@@ -67,5 +69,6 @@ int rxrpc_kernel_retry_call(struct socket , struct rxrpc_call ,
		struct sockaddr_rxrpc , struct key );
		int rxrpc_kernel_check_call(struct socket , struct rxrpc_call ,
		enum rxrpc_call_completion , u32 );
		u32 rxrpc_kernel_check_life(struct socket , struct rxrpc_call );

		#endif /* _NET_RXRPC_H */

net/rxrpc/af_rxrpc.c

+23 −1

Original line number	Diff line number	Diff line
		@@ -265,6 +265,7 @@ static int rxrpc_listen(struct socket *sock, int backlog)
		* @tx_total_len: Total length of data to transmit during the call (or -1)
		* @gfp: The allocation constraints
		* @notify_rx: Where to send notifications instead of socket queue
		* @upgrade: Request service upgrade for call
		*
		* Allow a kernel service to begin a call on the nominated socket. This just
		* sets up all the internal tracking structures and allocates connection and
		@@ -279,7 +280,8 @@ struct rxrpc_call rxrpc_kernel_begin_call(struct socket sock,
		unsigned long user_call_ID,
		s64 tx_total_len,
		gfp_t gfp,
		rxrpc_notify_rx_t notify_rx)
		rxrpc_notify_rx_t notify_rx,
		bool upgrade)
		{
		struct rxrpc_conn_parameters cp;
		struct rxrpc_call *call;
		@@ -304,6 +306,7 @@ struct rxrpc_call rxrpc_kernel_begin_call(struct socket sock,
		cp.key = key;
		cp.security_level = 0;
		cp.exclusive = false;
		cp.upgrade = upgrade;
		cp.service_id = srx->srx_service;
		call = rxrpc_new_client_call(rx, &cp, srx, user_call_ID, tx_total_len,
		gfp);
		@@ -336,6 +339,25 @@ void rxrpc_kernel_end_call(struct socket sock, struct rxrpc_call call)
		}
		EXPORT_SYMBOL(rxrpc_kernel_end_call);

		/**
		* rxrpc_kernel_check_life - Check to see whether a call is still alive
		* @sock: The socket the call is on
		* @call: The call to check
		*
		* Allow a kernel service to find out whether a call is still alive - ie. we're
		* getting ACKs from the server. Returns a number representing the life state
		* which can be compared to that returned by a previous call.
		*
		* If this is a client call, ping ACKs will be sent to the server to find out
		* whether it's still responsive and whether the call is still alive on the
		* server.
		*/
		u32 rxrpc_kernel_check_life(struct socket sock, struct rxrpc_call call)
		{
		return call->acks_latest;
		}
		EXPORT_SYMBOL(rxrpc_kernel_check_life);

		/**
		* rxrpc_kernel_check_call - Check a call's state
		* @sock: The socket the call is on

Admin message