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

Commit 3ab26a6f authored by David Howells's avatar David Howells
Browse files

rxrpc: Consolidate sendmsg parameters 



Consolidate the sendmsg control message parameters into a struct rather
than passing them individually through the argument list of
rxrpc_sendmsg_cmsg().  This makes it easier to add more parameters.

Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
parent 515559ca

net/rxrpc/sendmsg.c

+41 −42
Original line number Original line Diff line number Diff line
@@ -28,6 +28,14 @@ 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 {

	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
@@ -362,19 +370,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,45 +395,43 @@ 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;
@@ -455,8 +454,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 +478,10 @@ 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, GFP_KERNEL);

	/* The socket is now unlocked */

	/* The socket is now unlocked */





	_leave(" = %p\n", call);

	_leave(" = %p\n", call);
@@ -499,26 +497,28 @@ 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 = {

		.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 +526,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);
@@ -565,11 +564,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) {