Commit 7eca9cc5 authored by David S. Miller's avatar David S. Miller

Merge tag 'rxrpc-rewrite-20170607-v2' of...

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

David Howells says:

====================
rxrpc: Tx length parameter

Here's a set of patches that allows someone initiating a client call with
AF_RXRPC to indicate upfront the total amount of data that will be
transmitted.  This will allow AF_RXRPC to encrypt directly from source
buffer to packet rather than having to copy into the buffer and only
encrypt when it's full (the encrypted portion of the packet starts with a
length and so we can't encrypt until we know what the length will be).

The three patches are:

 (1) Provide a means of finding out what control message types are actually
     supported.  EINVAL is reported if an unsupported cmsg type is seen, so
     we don't want to set the new cmsg unless we know it will be accepted.

 (2) Consolidate some stuff into a struct to reduce the parameter count on
     the function that parses the cmsg buffer.

 (3) Introduce the RXRPC_TX_LENGTH cmsg.  This can be provided on the first
     sendmsg() that contributes data to a client call request or a service
     call reply.  If provided, the user must provide exactly that amount of
     data or an error will be incurred.

Changes in version 2:

 (*) struct rxrpc_send_params::tx_total_len should be s64 not u64.  Thanks to
     Julia Lawall for reporting this.
====================
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 546692e1 e754eba6
...@@ -327,6 +327,7 @@ calls, to invoke certain actions and to report certain conditions. These are: ...@@ -327,6 +327,7 @@ calls, to invoke certain actions and to report certain conditions. These are:
RXRPC_ACCEPT s-- n/a Accept new call RXRPC_ACCEPT s-- n/a Accept new call
RXRPC_EXCLUSIVE_CALL s-- n/a Make an exclusive client call RXRPC_EXCLUSIVE_CALL s-- n/a Make an exclusive client call
RXRPC_UPGRADE_SERVICE s-- n/a Client call can be upgraded RXRPC_UPGRADE_SERVICE s-- n/a Client call can be upgraded
RXRPC_TX_LENGTH s-- data len Total length of Tx data
(SRT = usable in Sendmsg / delivered by Recvmsg / Terminal message) (SRT = usable in Sendmsg / delivered by Recvmsg / Terminal message)
...@@ -406,6 +407,23 @@ calls, to invoke certain actions and to report certain conditions. These are: ...@@ -406,6 +407,23 @@ calls, to invoke certain actions and to report certain conditions. These are:
future communication to that server and RXRPC_UPGRADE_SERVICE should no future communication to that server and RXRPC_UPGRADE_SERVICE should no
longer be set. longer be set.
(*) RXRPC_TX_LENGTH
This is used to inform the kernel of the total amount of data that is
going to be transmitted by a call (whether in a client request or a
service response). If given, it allows the kernel to encrypt from the
userspace buffer directly to the packet buffers, rather than copying into
the buffer and then encrypting in place. This may only be given with the
first sendmsg() providing data for a call. EMSGSIZE will be generated if
the amount of data actually given is different.
This takes a parameter of __s64 type that indicates how much will be
transmitted. This may not be less than zero.
The symbol RXRPC__SUPPORTED is defined as one more than the highest control
message type supported. At run time this can be queried by means of the
RXRPC_SUPPORTED_CMSG socket option (see below).
============== ==============
SOCKET OPTIONS SOCKET OPTIONS
...@@ -459,6 +477,11 @@ AF_RXRPC sockets support a few socket options at the SOL_RXRPC level: ...@@ -459,6 +477,11 @@ AF_RXRPC sockets support a few socket options at the SOL_RXRPC level:
must point to an array of two unsigned short ints. The first is the must point to an array of two unsigned short ints. The first is the
service ID to upgrade from and the second the service ID to upgrade to. service ID to upgrade from and the second the service ID to upgrade to.
(*) RXRPC_SUPPORTED_CMSG
This is a read-only option that writes an int into the buffer indicating
the highest control message type supported.
======== ========
SECURITY SECURITY
...@@ -568,6 +591,9 @@ A client would issue an operation by: ...@@ -568,6 +591,9 @@ A client would issue an operation by:
MSG_MORE should be set in msghdr::msg_flags on all but the last part of MSG_MORE should be set in msghdr::msg_flags on all but the last part of
the request. Multiple requests may be made simultaneously. the request. Multiple requests may be made simultaneously.
An RXRPC_TX_LENGTH control message can also be specified on the first
sendmsg() call.
If a call is intended to go to a destination other than the default If a call is intended to go to a destination other than the default
specified through connect(), then msghdr::msg_name should be set on the specified through connect(), then msghdr::msg_name should be set on the
first request message of that call. first request message of that call.
...@@ -755,6 +781,7 @@ The kernel interface functions are as follows: ...@@ -755,6 +781,7 @@ The kernel interface functions are as follows:
struct sockaddr_rxrpc *srx, struct sockaddr_rxrpc *srx,
struct key *key, struct key *key,
unsigned long user_call_ID, unsigned long user_call_ID,
s64 tx_total_len,
gfp_t gfp); gfp_t gfp);
This allocates the infrastructure to make a new RxRPC call and assigns This allocates the infrastructure to make a new RxRPC call and assigns
...@@ -771,6 +798,11 @@ The kernel interface functions are as follows: ...@@ -771,6 +798,11 @@ The kernel interface functions are as follows:
control data buffer. It is entirely feasible to use this to point to a control data buffer. It is entirely feasible to use this to point to a
kernel data structure. kernel data structure.
tx_total_len is the amount of data the caller is intending to transmit
with this call (or -1 if unknown at this point). Setting the data size
allows the kernel to encrypt directly to the packet buffers, thereby
saving a copy. The value may not be less than -1.
If this function is successful, an opaque reference to the RxRPC call is 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 returned. The caller now holds a reference on this and it must be
properly ended. properly ended.
...@@ -922,6 +954,17 @@ The kernel interface functions are as follows: ...@@ -922,6 +954,17 @@ The kernel interface functions are as follows:
This is used to find the remote peer address of a call. This is used to find the remote peer address of a call.
(*) Set the total transmit data size on a call.
void rxrpc_kernel_set_tx_length(struct socket *sock,
struct rxrpc_call *call,
s64 tx_total_len);
This sets the amount of data that the caller is intending to transmit on a
call. It's intended to be used for setting the reply size as the request
size should be set when the call is begun. tx_total_len may not be less
than zero.
======================= =======================
CONFIGURABLE PARAMETERS CONFIGURABLE PARAMETERS
......
...@@ -341,6 +341,7 @@ int afs_make_call(struct in_addr *addr, struct afs_call *call, gfp_t gfp, ...@@ -341,6 +341,7 @@ int afs_make_call(struct in_addr *addr, struct afs_call *call, gfp_t gfp,
struct msghdr msg; struct msghdr msg;
struct kvec iov[1]; struct kvec iov[1];
size_t offset; size_t offset;
s64 tx_total_len;
u32 abort_code; u32 abort_code;
int ret; int ret;
...@@ -364,9 +365,20 @@ int afs_make_call(struct in_addr *addr, struct afs_call *call, gfp_t gfp, ...@@ -364,9 +365,20 @@ int afs_make_call(struct in_addr *addr, struct afs_call *call, gfp_t gfp,
srx.transport.sin.sin_port = call->port; srx.transport.sin.sin_port = call->port;
memcpy(&srx.transport.sin.sin_addr, addr, 4); memcpy(&srx.transport.sin.sin_addr, addr, 4);
/* Work out the length we're going to transmit. This is awkward for
* calls such as FS.StoreData where there's an extra injection of data
* after the initial fixed part.
*/
tx_total_len = call->request_size;
if (call->send_pages) {
tx_total_len += call->last_to - call->first_offset;
tx_total_len += (call->last - call->first) * PAGE_SIZE;
}
/* create a call */ /* create a call */
rxcall = rxrpc_kernel_begin_call(afs_socket, &srx, call->key, rxcall = rxrpc_kernel_begin_call(afs_socket, &srx, call->key,
(unsigned long) call, gfp, (unsigned long)call,
tx_total_len, gfp,
(async ? (async ?
afs_wake_up_async_call : afs_wake_up_async_call :
afs_wake_up_call_waiter)); afs_wake_up_call_waiter));
...@@ -738,6 +750,8 @@ void afs_send_empty_reply(struct afs_call *call) ...@@ -738,6 +750,8 @@ void afs_send_empty_reply(struct afs_call *call)
_enter(""); _enter("");
rxrpc_kernel_set_tx_length(afs_socket, call->rxcall, 0);
msg.msg_name = NULL; msg.msg_name = NULL;
msg.msg_namelen = 0; msg.msg_namelen = 0;
iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, NULL, 0, 0); iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, NULL, 0, 0);
...@@ -772,6 +786,8 @@ void afs_send_simple_reply(struct afs_call *call, const void *buf, size_t len) ...@@ -772,6 +786,8 @@ void afs_send_simple_reply(struct afs_call *call, const void *buf, size_t len)
_enter(""); _enter("");
rxrpc_kernel_set_tx_length(afs_socket, call->rxcall, len);
iov[0].iov_base = (void *) buf; iov[0].iov_base = (void *) buf;
iov[0].iov_len = len; iov[0].iov_len = len;
msg.msg_name = NULL; msg.msg_name = NULL;
......
...@@ -38,6 +38,7 @@ struct sockaddr_rxrpc { ...@@ -38,6 +38,7 @@ struct sockaddr_rxrpc {
#define RXRPC_EXCLUSIVE_CONNECTION 3 /* Deprecated; use RXRPC_EXCLUSIVE_CALL instead */ #define RXRPC_EXCLUSIVE_CONNECTION 3 /* Deprecated; use RXRPC_EXCLUSIVE_CALL instead */
#define RXRPC_MIN_SECURITY_LEVEL 4 /* minimum security level */ #define RXRPC_MIN_SECURITY_LEVEL 4 /* minimum security level */
#define RXRPC_UPGRADEABLE_SERVICE 5 /* Upgrade service[0] -> service[1] */ #define RXRPC_UPGRADEABLE_SERVICE 5 /* Upgrade service[0] -> service[1] */
#define RXRPC_SUPPORTED_CMSG 6 /* Get highest supported control message type */
/* /*
* RxRPC control messages * RxRPC control messages
...@@ -45,16 +46,20 @@ struct sockaddr_rxrpc { ...@@ -45,16 +46,20 @@ struct sockaddr_rxrpc {
* - terminal messages mean that a user call ID tag can be recycled * - terminal messages mean that a user call ID tag can be recycled
* - s/r/- indicate whether these are applicable to sendmsg() and/or recvmsg() * - s/r/- indicate whether these are applicable to sendmsg() and/or recvmsg()
*/ */
#define RXRPC_USER_CALL_ID 1 /* sr: user call ID specifier */ enum rxrpc_cmsg_type {
#define RXRPC_ABORT 2 /* sr: abort request / notification [terminal] */ RXRPC_USER_CALL_ID = 1, /* sr: user call ID specifier */
#define RXRPC_ACK 3 /* -r: [Service] RPC op final ACK received [terminal] */ RXRPC_ABORT = 2, /* sr: abort request / notification [terminal] */
#define RXRPC_NET_ERROR 5 /* -r: network error received [terminal] */ RXRPC_ACK = 3, /* -r: [Service] RPC op final ACK received [terminal] */
#define RXRPC_BUSY 6 /* -r: server busy received [terminal] */ RXRPC_NET_ERROR = 5, /* -r: network error received [terminal] */
#define RXRPC_LOCAL_ERROR 7 /* -r: local error generated [terminal] */ RXRPC_BUSY = 6, /* -r: server busy received [terminal] */
#define RXRPC_NEW_CALL 8 /* -r: [Service] new incoming call notification */ RXRPC_LOCAL_ERROR = 7, /* -r: local error generated [terminal] */
#define RXRPC_ACCEPT 9 /* s-: [Service] accept request */ RXRPC_NEW_CALL = 8, /* -r: [Service] new incoming call notification */
#define RXRPC_EXCLUSIVE_CALL 10 /* s-: Call should be on exclusive connection */ RXRPC_ACCEPT = 9, /* s-: [Service] accept request */
#define RXRPC_UPGRADE_SERVICE 11 /* s-: Request service upgrade for client call */ RXRPC_EXCLUSIVE_CALL = 10, /* s-: Call should be on exclusive connection */
RXRPC_UPGRADE_SERVICE = 11, /* s-: Request service upgrade for client call */
RXRPC_TX_LENGTH = 12, /* s-: Total length of Tx data */
RXRPC__SUPPORTED
};
/* /*
* RxRPC security levels * RxRPC security levels
......
...@@ -33,6 +33,7 @@ struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *, ...@@ -33,6 +33,7 @@ struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *,
struct sockaddr_rxrpc *, struct sockaddr_rxrpc *,
struct key *, struct key *,
unsigned long, unsigned long,
s64,
gfp_t, gfp_t,
rxrpc_notify_rx_t); rxrpc_notify_rx_t);
int rxrpc_kernel_send_data(struct socket *, struct rxrpc_call *, int rxrpc_kernel_send_data(struct socket *, struct rxrpc_call *,
...@@ -46,5 +47,6 @@ void rxrpc_kernel_get_peer(struct socket *, struct rxrpc_call *, ...@@ -46,5 +47,6 @@ void rxrpc_kernel_get_peer(struct socket *, struct rxrpc_call *,
struct sockaddr_rxrpc *); struct sockaddr_rxrpc *);
int rxrpc_kernel_charge_accept(struct socket *, rxrpc_notify_rx_t, int rxrpc_kernel_charge_accept(struct socket *, rxrpc_notify_rx_t,
rxrpc_user_attach_call_t, unsigned long, gfp_t); rxrpc_user_attach_call_t, unsigned long, gfp_t);
void rxrpc_kernel_set_tx_length(struct socket *, struct rxrpc_call *, s64);
#endif /* _NET_RXRPC_H */ #endif /* _NET_RXRPC_H */
...@@ -262,6 +262,7 @@ static int rxrpc_listen(struct socket *sock, int backlog) ...@@ -262,6 +262,7 @@ static int rxrpc_listen(struct socket *sock, int backlog)
* @srx: The address of the peer to contact * @srx: The address of the peer to contact
* @key: The security context to use (defaults to socket setting) * @key: The security context to use (defaults to socket setting)
* @user_call_ID: The ID to use * @user_call_ID: The ID to use
* @tx_total_len: Total length of data to transmit during the call (or -1)
* @gfp: The allocation constraints * @gfp: The allocation constraints
* @notify_rx: Where to send notifications instead of socket queue * @notify_rx: Where to send notifications instead of socket queue
* *
...@@ -276,6 +277,7 @@ struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *sock, ...@@ -276,6 +277,7 @@ struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *sock,
struct sockaddr_rxrpc *srx, struct sockaddr_rxrpc *srx,
struct key *key, struct key *key,
unsigned long user_call_ID, unsigned long user_call_ID,
s64 tx_total_len,
gfp_t gfp, gfp_t gfp,
rxrpc_notify_rx_t notify_rx) rxrpc_notify_rx_t notify_rx)
{ {
...@@ -303,7 +305,8 @@ struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *sock, ...@@ -303,7 +305,8 @@ struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *sock,
cp.security_level = 0; cp.security_level = 0;
cp.exclusive = false; cp.exclusive = false;
cp.service_id = srx->srx_service; cp.service_id = srx->srx_service;
call = rxrpc_new_client_call(rx, &cp, srx, user_call_ID, gfp); call = rxrpc_new_client_call(rx, &cp, srx, user_call_ID, tx_total_len,
gfp);
/* The socket has been unlocked. */ /* The socket has been unlocked. */
if (!IS_ERR(call)) if (!IS_ERR(call))
call->notify_rx = notify_rx; call->notify_rx = notify_rx;
...@@ -581,6 +584,34 @@ static int rxrpc_setsockopt(struct socket *sock, int level, int optname, ...@@ -581,6 +584,34 @@ static int rxrpc_setsockopt(struct socket *sock, int level, int optname,
return ret; return ret;
} }
/*
* Get socket options.
*/
static int rxrpc_getsockopt(struct socket *sock, int level, int optname,
char __user *optval, int __user *_optlen)
{
int optlen;
if (level != SOL_RXRPC)
return -EOPNOTSUPP;
if (get_user(optlen, _optlen))
return -EFAULT;
switch (optname) {
case RXRPC_SUPPORTED_CMSG:
if (optlen < sizeof(int))
return -ETOOSMALL;
if (put_user(RXRPC__SUPPORTED - 1, (int __user *)optval) ||
put_user(sizeof(int), _optlen))
return -EFAULT;
return 0;
default:
return -EOPNOTSUPP;
}
}
/* /*
* permit an RxRPC socket to be polled * permit an RxRPC socket to be polled
*/ */
...@@ -784,7 +815,7 @@ static const struct proto_ops rxrpc_rpc_ops = { ...@@ -784,7 +815,7 @@ static const struct proto_ops rxrpc_rpc_ops = {
.listen = rxrpc_listen, .listen = rxrpc_listen,
.shutdown = rxrpc_shutdown, .shutdown = rxrpc_shutdown,
.setsockopt = rxrpc_setsockopt, .setsockopt = rxrpc_setsockopt,
.getsockopt = sock_no_getsockopt, .getsockopt = rxrpc_getsockopt,
.sendmsg = rxrpc_sendmsg, .sendmsg = rxrpc_sendmsg,
.recvmsg = rxrpc_recvmsg, .recvmsg = rxrpc_recvmsg,
.mmap = sock_no_mmap, .mmap = sock_no_mmap,
......
...@@ -528,6 +528,7 @@ struct rxrpc_call { ...@@ -528,6 +528,7 @@ struct rxrpc_call {
struct rb_node sock_node; /* Node in rx->calls */ struct rb_node sock_node; /* Node in rx->calls */
struct sk_buff *tx_pending; /* Tx socket buffer being filled */ struct sk_buff *tx_pending; /* Tx socket buffer being filled */
wait_queue_head_t waitq; /* Wait queue for channel or Tx */ wait_queue_head_t waitq; /* Wait queue for channel or Tx */
s64 tx_total_len; /* Total length left to be transmitted (or -1) */
__be32 crypto_buf[2]; /* Temporary packet crypto buffer */ __be32 crypto_buf[2]; /* Temporary packet crypto buffer */
unsigned long user_call_ID; /* user-defined call ID */ unsigned long user_call_ID; /* user-defined call ID */
unsigned long flags; unsigned long flags;
...@@ -683,7 +684,7 @@ struct rxrpc_call *rxrpc_alloc_call(gfp_t); ...@@ -683,7 +684,7 @@ struct rxrpc_call *rxrpc_alloc_call(gfp_t);
struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *, struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *,
struct rxrpc_conn_parameters *, struct rxrpc_conn_parameters *,
struct sockaddr_rxrpc *, struct sockaddr_rxrpc *,
unsigned long, gfp_t); unsigned long, s64, gfp_t);
void rxrpc_incoming_call(struct rxrpc_sock *, struct rxrpc_call *, void rxrpc_incoming_call(struct rxrpc_sock *, struct rxrpc_call *,
struct sk_buff *); struct sk_buff *);
void rxrpc_release_call(struct rxrpc_sock *, struct rxrpc_call *); void rxrpc_release_call(struct rxrpc_sock *, struct rxrpc_call *);
......
...@@ -127,6 +127,7 @@ struct rxrpc_call *rxrpc_alloc_call(gfp_t gfp) ...@@ -127,6 +127,7 @@ struct rxrpc_call *rxrpc_alloc_call(gfp_t gfp)
rwlock_init(&call->state_lock); rwlock_init(&call->state_lock);
atomic_set(&call->usage, 1); atomic_set(&call->usage, 1);
call->debug_id = atomic_inc_return(&rxrpc_debug_id); call->debug_id = atomic_inc_return(&rxrpc_debug_id);
call->tx_total_len = -1;
memset(&call->sock_node, 0xed, sizeof(call->sock_node)); memset(&call->sock_node, 0xed, sizeof(call->sock_node));
...@@ -201,6 +202,7 @@ struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *rx, ...@@ -201,6 +202,7 @@ struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *rx,
struct rxrpc_conn_parameters *cp, struct rxrpc_conn_parameters *cp,
struct sockaddr_rxrpc *srx, struct sockaddr_rxrpc *srx,
unsigned long user_call_ID, unsigned long user_call_ID,
s64 tx_total_len,
gfp_t gfp) gfp_t gfp)
__releases(&rx->sk.sk_lock.slock) __releases(&rx->sk.sk_lock.slock)
{ {
...@@ -219,6 +221,7 @@ struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *rx, ...@@ -219,6 +221,7 @@ struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *rx,
return call; return call;
} }
call->tx_total_len = tx_total_len;
trace_rxrpc_call(call, rxrpc_call_new_client, atomic_read(&call->usage), trace_rxrpc_call(call, rxrpc_call_new_client, atomic_read(&call->usage),
here, (const void *)user_call_ID); here, (const void *)user_call_ID);
......
...@@ -28,6 +28,15 @@ enum rxrpc_command { ...@@ -28,6 +28,15 @@ enum rxrpc_command {
RXRPC_CMD_REJECT_BUSY, /* [server] reject a call as busy */ RXRPC_CMD_REJECT_BUSY, /* [server] reject a call as busy */
}; };
struct rxrpc_send_params {
s64 tx_total_len; /* Total Tx data length (if send data) */
unsigned long user_call_ID; /* User's call ID */
u32 abort_code; /* Abort code to Tx (if abort) */
enum rxrpc_command command : 8; /* The command to implement */
bool exclusive; /* Shared or exclusive call */
bool upgrade; /* If the connection is upgradeable */
};
/* /*
* wait for space to appear in the transmit/ACK window * wait for space to appear in the transmit/ACK window
* - caller holds the socket locked * - caller holds the socket locked
...@@ -199,6 +208,13 @@ static int rxrpc_send_data(struct rxrpc_sock *rx, ...@@ -199,6 +208,13 @@ static int rxrpc_send_data(struct rxrpc_sock *rx,
more = msg->msg_flags & MSG_MORE; more = msg->msg_flags & MSG_MORE;
if (call->tx_total_len != -1) {
if (len > call->tx_total_len)
return -EMSGSIZE;
if (!more && len != call->tx_total_len)
return -EMSGSIZE;
}
skb = call->tx_pending; skb = call->tx_pending;
call->tx_pending = NULL; call->tx_pending = NULL;
rxrpc_see_skb(skb, rxrpc_skb_tx_seen); rxrpc_see_skb(skb, rxrpc_skb_tx_seen);
...@@ -291,6 +307,8 @@ static int rxrpc_send_data(struct rxrpc_sock *rx, ...@@ -291,6 +307,8 @@ static int rxrpc_send_data(struct rxrpc_sock *rx,
sp->remain -= copy; sp->remain -= copy;
skb->mark += copy; skb->mark += copy;
copied += copy; copied += copy;
if (call->tx_total_len != -1)
call->tx_total_len -= copy;
} }
/* check for the far side aborting the call or a network error /* check for the far side aborting the call or a network error
...@@ -362,19 +380,12 @@ static int rxrpc_send_data(struct rxrpc_sock *rx, ...@@ -362,19 +380,12 @@ static int rxrpc_send_data(struct rxrpc_sock *rx,
/* /*
* extract control messages from the sendmsg() control buffer * extract control messages from the sendmsg() control buffer
*/ */
static int rxrpc_sendmsg_cmsg(struct msghdr *msg, static int rxrpc_sendmsg_cmsg(struct msghdr *msg, struct rxrpc_send_params *p)
unsigned long *user_call_ID,
enum rxrpc_command *command,
u32 *abort_code,
bool *_exclusive,
bool *_upgrade)
{ {
struct cmsghdr *cmsg; struct cmsghdr *cmsg;
bool got_user_ID = false; bool got_user_ID = false;
int len; int len;
*command = RXRPC_CMD_SEND_DATA;
if (msg->msg_controllen == 0) if (msg->msg_controllen == 0)
return -EINVAL; return -EINVAL;
...@@ -394,49 +405,55 @@ static int rxrpc_sendmsg_cmsg(struct msghdr *msg, ...@@ -394,49 +405,55 @@ static int rxrpc_sendmsg_cmsg(struct msghdr *msg,
if (msg->msg_flags & MSG_CMSG_COMPAT) { if (msg->msg_flags & MSG_CMSG_COMPAT) {
if (len != sizeof(u32)) if (len != sizeof(u32))
return -EINVAL; return -EINVAL;
*user_call_ID = *(u32 *) CMSG_DATA(cmsg); p->user_call_ID = *(u32 *)CMSG_DATA(cmsg);
} else { } else {
if (len != sizeof(unsigned long)) if (len != sizeof(unsigned long))
return -EINVAL; return -EINVAL;
*user_call_ID = *(unsigned long *) p->user_call_ID = *(unsigned long *)
CMSG_DATA(cmsg); CMSG_DATA(cmsg);
} }
_debug("User Call ID %lx", *user_call_ID);
got_user_ID = true; got_user_ID = true;
break; break;
case RXRPC_ABORT: case RXRPC_ABORT:
if (*command != RXRPC_CMD_SEND_DATA) if (p->command != RXRPC_CMD_SEND_DATA)
return -EINVAL; return -EINVAL;
*command = RXRPC_CMD_SEND_ABORT; p->command = RXRPC_CMD_SEND_ABORT;
if (len != sizeof(*abort_code)) if (len != sizeof(p->abort_code))
return -EINVAL; return -EINVAL;
*abort_code = *(unsigned int *) CMSG_DATA(cmsg); p->abort_code = *(unsigned int *)CMSG_DATA(cmsg);
_debug("Abort %x", *abort_code); if (p->abort_code == 0)
if (*abort_code == 0)
return -EINVAL; return -EINVAL;
break; break;
case RXRPC_ACCEPT: case RXRPC_ACCEPT:
if (*command != RXRPC_CMD_SEND_DATA) if (p->command != RXRPC_CMD_SEND_DATA)
return -EINVAL; return -EINVAL;
*command = RXRPC_CMD_ACCEPT; p->command = RXRPC_CMD_ACCEPT;
if (len != 0) if (len != 0)
return -EINVAL; return -EINVAL;
break; break;
case RXRPC_EXCLUSIVE_CALL: case RXRPC_EXCLUSIVE_CALL:
*_exclusive = true; p->exclusive = true;
if (len != 0) if (len != 0)
return -EINVAL; return -EINVAL;
break; break;
case RXRPC_UPGRADE_SERVICE: case RXRPC_UPGRADE_SERVICE:
*_upgrade = true; p->upgrade = true;
if (len != 0) if (len != 0)
return -EINVAL; return -EINVAL;
break; break;
case RXRPC_TX_LENGTH:
if (p->tx_total_len != -1 || len != sizeof(__s64))
return -EINVAL;
p->tx_total_len = *(__s64 *)CMSG_DATA(cmsg);
if (p->tx_total_len < 0)
return -EINVAL;
break;
default: default:
return -EINVAL; return -EINVAL;
} }
...@@ -444,6 +461,8 @@ static int rxrpc_sendmsg_cmsg(struct msghdr *msg, ...@@ -444,6 +461,8 @@ static int rxrpc_sendmsg_cmsg(struct msghdr *msg,
if (!got_user_ID) if (!got_user_ID)
return -EINVAL; return -EINVAL;
if (p->tx_total_len != -1 && p->command != RXRPC_CMD_SEND_DATA)
return -EINVAL;
_leave(" = 0"); _leave(" = 0");
return 0; return 0;
} }
...@@ -455,8 +474,7 @@ static int rxrpc_sendmsg_cmsg(struct msghdr *msg, ...@@ -455,8 +474,7 @@ static int rxrpc_sendmsg_cmsg(struct msghdr *msg,
*/ */
static struct rxrpc_call * static struct rxrpc_call *
rxrpc_new_client_call_for_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, rxrpc_new_client_call_for_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg,
unsigned long user_call_ID, bool exclusive, struct rxrpc_send_params *p)
bool upgrade)
__releases(&rx->sk.sk_lock.slock) __releases(&rx->sk.sk_lock.slock)
{ {
struct rxrpc_conn_parameters cp; struct rxrpc_conn_parameters cp;
...@@ -480,10 +498,11 @@ rxrpc_new_client_call_for_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, ...@@ -480,10 +498,11 @@ rxrpc_new_client_call_for_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg,
cp.local = rx->local; cp.local = rx->local;
cp.key = rx->key; cp.key = rx->key;
cp.security_level = rx->min_sec_level; cp.security_level = rx->min_sec_level;
cp.exclusive = rx->exclusive | exclusive; cp.exclusive = rx->exclusive | p->exclusive;
cp.upgrade = upgrade; cp.upgrade = p->upgrade;
cp.service_id = srx->srx_service; cp.service_id = srx->srx_service;
call = rxrpc_new_client_call(rx, &cp, srx, user_call_ID, GFP_KERNEL); call = rxrpc_new_client_call(rx, &cp, srx, p->user_call_ID,
p->tx_total_len, GFP_KERNEL);
/* The socket is now unlocked */ /* The socket is now unlocked */
_leave(" = %p\n", call); _leave(" = %p\n", call);
...@@ -499,26 +518,29 @@ int rxrpc_do_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, size_t len) ...@@ -499,26 +518,29 @@ int rxrpc_do_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, size_t len)
__releases(&rx->sk.sk_lock.slock) __releases(&rx->sk.sk_lock.slock)
{ {
enum rxrpc_call_state state; enum rxrpc_call_state state;
enum rxrpc_command cmd;
struct rxrpc_call *call; struct rxrpc_call *call;
unsigned long user_call_ID = 0;
bool exclusive = false;
bool upgrade = true;
u32 abort_code = 0;
int ret; int ret;
struct rxrpc_send_params p = {
.tx_total_len = -1,
.user_call_ID = 0,
.abort_code = 0,
.command = RXRPC_CMD_SEND_DATA,
.exclusive = false,
.upgrade = true,
};
_enter(""); _enter("");
ret = rxrpc_sendmsg_cmsg(msg, &user_call_ID, &cmd, &abort_code, ret = rxrpc_sendmsg_cmsg(msg, &p);
&exclusive, &upgrade);
if (ret < 0) if (ret < 0)
goto error_release_sock; goto error_release_sock;
if (cmd == RXRPC_CMD_ACCEPT) { if (p.command == RXRPC_CMD_ACCEPT) {
ret = -EINVAL; ret = -EINVAL;
if (rx->sk.sk_state != RXRPC_SERVER_LISTENING) if (rx->sk.sk_state != RXRPC_SERVER_LISTENING)
goto error_release_sock; goto error_release_sock;
call = rxrpc_accept_call(rx, user_call_ID, NULL); call = rxrpc_accept_call(rx, p.user_call_ID, NULL);
/* The socket is now unlocked. */ /* The socket is now unlocked. */
if (IS_ERR(call)) if (IS_ERR(call))
return PTR_ERR(call); return PTR_ERR(call);
...@@ -526,13 +548,12 @@ int rxrpc_do_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, size_t len) ...@@ -526,13 +548,12 @@ int rxrpc_do_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, size_t len)
return 0; return 0;
} }
call = rxrpc_find_call_by_user_ID(rx, user_call_ID); call = rxrpc_find_call_by_user_ID(rx, p.user_call_ID);
if (!call) { if (!call) {
ret = -EBADSLT; ret = -EBADSLT;
if (cmd != RXRPC_CMD_SEND_DATA) if (p.command != RXRPC_CMD_SEND_DATA)
goto error_release_sock; goto error_release_sock;
call = rxrpc_new_client_call_for_sendmsg(rx, msg, user_call_ID, call = rxrpc_new_client_call_for_sendmsg(rx, msg, &p);
exclusive, upgrade);
/* The socket is now unlocked... */ /* The socket is now unlocked... */
if (IS_ERR(call)) if (IS_ERR(call))
return PTR_ERR(call); return PTR_ERR(call);
...@@ -556,6 +577,15 @@ int rxrpc_do_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, size_t len) ...@@ -556,6 +577,15 @@ int rxrpc_do_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, size_t len)
ret = -ERESTARTSYS; ret = -ERESTARTSYS;
goto error_put; goto error_put;
} }
if (p.tx_total_len != -1) {
ret = -EINVAL;
if (call->tx_total_len != -1 ||
call->tx_pending ||
call->tx_top != 0)
goto error_put;
call->tx_total_len = p.tx_total_len;
}
} }
state = READ_ONCE(call->state); state = READ_ONCE(call->state);
...@@ -565,11 +595,11 @@ int rxrpc_do_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, size_t len) ...@@ -565,11 +595,11 @@ int rxrpc_do_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, size_t len)
if (state >= RXRPC_CALL_COMPLETE) { if (state >= RXRPC_CALL_COMPLETE) {
/* it's too late for this call */ /* it's too late for this call */
ret = -ESHUTDOWN; ret = -ESHUTDOWN;
} else if (cmd == RXRPC_CMD_SEND_ABORT) { } else if (p.command == RXRPC_CMD_SEND_ABORT) {
ret = 0; ret = 0;
if (rxrpc_abort_call("CMD", call, 0, abort_code, -ECONNABORTED)) if (rxrpc_abort_call("CMD", call, 0, p.abort_code, -ECONNABORTED))
ret = rxrpc_send_abort_packet(call); ret = rxrpc_send_abort_packet(call);
} else if (cmd != RXRPC_CMD_SEND_DATA) { } else if (p.command != RXRPC_CMD_SEND_DATA) {
ret = -EINVAL; ret = -EINVAL;
} else if (rxrpc_is_client_call(call) && } else if (rxrpc_is_client_call(call) &&
state != RXRPC_CALL_CLIENT_SEND_REQUEST) { state != RXRPC_CALL_CLIENT_SEND_REQUEST) {
...@@ -673,5 +703,24 @@ bool rxrpc_kernel_abort_call(struct socket *sock, struct rxrpc_call *call, ...@@ -673,5 +703,24 @@ bool rxrpc_kernel_abort_call(struct socket *sock, struct rxrpc_call *call,
mutex_unlock(&call->user_mutex); mutex_unlock(&call->user_mutex);
return aborted; return aborted;
} }
EXPORT_SYMBOL(rxrpc_kernel_abort_call); EXPORT_SYMBOL(rxrpc_kernel_abort_call);
/**
* rxrpc_kernel_set_tx_length - Set the total Tx length on a call
* @sock: The socket the call is on
* @call: The call to be informed
* @tx_total_len: The amount of data to be transmitted for this call
*
* Allow a kernel service to set the total transmit length on a call. This
* allows buffer-to-packet encrypt-and-copy to be performed.
*
* This function is primarily for use for setting the reply length since the
* request length can be set when beginning the call.
*/
void rxrpc_kernel_set_tx_length(struct socket *sock, struct rxrpc_call *call,
s64 tx_total_len)
{
WARN_ON(call->tx_total_len != -1);
call->tx_total_len = tx_total_len;
}
EXPORT_SYMBOL(rxrpc_kernel_set_tx_length);
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment