Commit 4c198ad1 authored by David Howells's avatar David Howells
Browse files

rxrpc: Rename call events to begin RXRPC_CALL_EV_ 



Rename call event names to begin RXRPC_CALL_EV_ to distinguish them from the
flags.

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

net/rxrpc/ar-accept.c

+5 −5
Original line number Diff line number Diff line
@@ -186,7 +186,7 @@ static int rxrpc_accept_incoming_call(struct rxrpc_local *local, 


	read_lock_bh(&call->state_lock);

	if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&

	    !test_and_set_bit(RXRPC_CALL_RELEASE, &call->events)) {

	    !test_and_set_bit(RXRPC_CALL_EV_RELEASE, &call->events)) {

		rxrpc_get_call(call);

		rxrpc_queue_call(call);

	}
@@ -379,7 +379,7 @@ struct rxrpc_call *rxrpc_accept_call(struct rxrpc_sock *rx, 
	rb_insert_color(&call->sock_node, &rx->calls);

	if (test_and_set_bit(RXRPC_CALL_HAS_USERID, &call->flags))

		BUG();

	if (test_and_set_bit(RXRPC_CALL_ACCEPTED, &call->events))

	if (test_and_set_bit(RXRPC_CALL_EV_ACCEPTED, &call->events))

		BUG();

	rxrpc_queue_call(call);
@@ -395,7 +395,7 @@ struct rxrpc_call *rxrpc_accept_call(struct rxrpc_sock *rx, 
out_release:

	_debug("release %p", call);

	if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&

	    !test_and_set_bit(RXRPC_CALL_RELEASE, &call->events))

	    !test_and_set_bit(RXRPC_CALL_EV_RELEASE, &call->events))

		rxrpc_queue_call(call);

out_discard:

	write_unlock_bh(&call->state_lock);
@@ -434,7 +434,7 @@ int rxrpc_reject_call(struct rxrpc_sock *rx) 
	switch (call->state) {

	case RXRPC_CALL_SERVER_ACCEPTING:

		call->state = RXRPC_CALL_SERVER_BUSY;

		if (test_and_set_bit(RXRPC_CALL_REJECT_BUSY, &call->events))

		if (test_and_set_bit(RXRPC_CALL_EV_REJECT_BUSY, &call->events))

			rxrpc_queue_call(call);

		ret = 0;

		goto out_release;
@@ -458,7 +458,7 @@ int rxrpc_reject_call(struct rxrpc_sock *rx) 
out_release:

	_debug("release %p", call);

	if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&

	    !test_and_set_bit(RXRPC_CALL_RELEASE, &call->events))

	    !test_and_set_bit(RXRPC_CALL_EV_RELEASE, &call->events))

		rxrpc_queue_call(call);

out_discard:

	write_unlock_bh(&call->state_lock);

net/rxrpc/ar-ack.c

+51 −51
Original line number Diff line number Diff line
@@ -161,7 +161,7 @@ void __rxrpc_propose_ACK(struct rxrpc_call *call, u8 ack_reason, 
	try_to_del_timer_sync(&call->ack_timer);

	read_lock_bh(&call->state_lock);

	if (call->state <= RXRPC_CALL_COMPLETE &&

	    !test_and_set_bit(RXRPC_CALL_ACK, &call->events))

	    !test_and_set_bit(RXRPC_CALL_EV_ACK, &call->events))

		rxrpc_queue_call(call);

	read_unlock_bh(&call->state_lock);

}
@@ -193,7 +193,7 @@ static void rxrpc_set_resend(struct rxrpc_call *call, u8 resend, 


	if (resend & 1) {

		_debug("SET RESEND");

		set_bit(RXRPC_CALL_RESEND, &call->events);

		set_bit(RXRPC_CALL_EV_RESEND, &call->events);

	}



	if (resend & 2) {
@@ -203,7 +203,7 @@ static void rxrpc_set_resend(struct rxrpc_call *call, u8 resend, 
	} else {

		_debug("KILL RESEND TIMER");

		del_timer_sync(&call->resend_timer);

		clear_bit(RXRPC_CALL_RESEND_TIMER, &call->events);

		clear_bit(RXRPC_CALL_EV_RESEND_TIMER, &call->events);

		clear_bit(RXRPC_CALL_RUN_RTIMER, &call->flags);

	}

	read_unlock_bh(&call->state_lock);
@@ -555,7 +555,7 @@ static void rxrpc_insert_oos_packet(struct rxrpc_call *call, 
	if (call->state < RXRPC_CALL_COMPLETE &&

	    call->rx_data_post == call->rx_first_oos) {

		_debug("drain rx oos now");

		set_bit(RXRPC_CALL_DRAIN_RX_OOS, &call->events);

		set_bit(RXRPC_CALL_EV_DRAIN_RX_OOS, &call->events);

	}

	read_unlock(&call->state_lock);
@@ -793,7 +793,7 @@ static int rxrpc_process_rx_queue(struct rxrpc_call *call, 


	del_timer_sync(&call->resend_timer);

	clear_bit(RXRPC_CALL_RUN_RTIMER, &call->flags);

	clear_bit(RXRPC_CALL_RESEND_TIMER, &call->events);

	clear_bit(RXRPC_CALL_EV_RESEND_TIMER, &call->events);



	if (call->acks_window)

		rxrpc_zap_tx_window(call);
@@ -928,17 +928,17 @@ void rxrpc_process_call(struct work_struct *work) 
	iov[0].iov_len	= sizeof(hdr);



	/* deal with events of a final nature */

	if (test_bit(RXRPC_CALL_RELEASE, &call->events)) {

	if (test_bit(RXRPC_CALL_EV_RELEASE, &call->events)) {

		rxrpc_release_call(call);

		clear_bit(RXRPC_CALL_RELEASE, &call->events);

		clear_bit(RXRPC_CALL_EV_RELEASE, &call->events);

	}



	if (test_bit(RXRPC_CALL_RCVD_ERROR, &call->events)) {

	if (test_bit(RXRPC_CALL_EV_RCVD_ERROR, &call->events)) {

		int error;



		clear_bit(RXRPC_CALL_CONN_ABORT, &call->events);

		clear_bit(RXRPC_CALL_REJECT_BUSY, &call->events);

		clear_bit(RXRPC_CALL_ABORT, &call->events);

		clear_bit(RXRPC_CALL_EV_CONN_ABORT, &call->events);

		clear_bit(RXRPC_CALL_EV_REJECT_BUSY, &call->events);

		clear_bit(RXRPC_CALL_EV_ABORT, &call->events);



		error = call->conn->trans->peer->net_error;

		_debug("post net error %d", error);
@@ -946,32 +946,32 @@ void rxrpc_process_call(struct work_struct *work) 
		if (rxrpc_post_message(call, RXRPC_SKB_MARK_NET_ERROR,

				       error, true) < 0)

			goto no_mem;

		clear_bit(RXRPC_CALL_RCVD_ERROR, &call->events);

		clear_bit(RXRPC_CALL_EV_RCVD_ERROR, &call->events);

		goto kill_ACKs;

	}



	if (test_bit(RXRPC_CALL_CONN_ABORT, &call->events)) {

	if (test_bit(RXRPC_CALL_EV_CONN_ABORT, &call->events)) {

		ASSERTCMP(call->state, >, RXRPC_CALL_COMPLETE);



		clear_bit(RXRPC_CALL_REJECT_BUSY, &call->events);

		clear_bit(RXRPC_CALL_ABORT, &call->events);

		clear_bit(RXRPC_CALL_EV_REJECT_BUSY, &call->events);

		clear_bit(RXRPC_CALL_EV_ABORT, &call->events);



		_debug("post conn abort");



		if (rxrpc_post_message(call, RXRPC_SKB_MARK_LOCAL_ERROR,

				       call->conn->error, true) < 0)

			goto no_mem;

		clear_bit(RXRPC_CALL_CONN_ABORT, &call->events);

		clear_bit(RXRPC_CALL_EV_CONN_ABORT, &call->events);

		goto kill_ACKs;

	}



	if (test_bit(RXRPC_CALL_REJECT_BUSY, &call->events)) {

	if (test_bit(RXRPC_CALL_EV_REJECT_BUSY, &call->events)) {

		hdr.type = RXRPC_PACKET_TYPE_BUSY;

		genbit = RXRPC_CALL_REJECT_BUSY;

		genbit = RXRPC_CALL_EV_REJECT_BUSY;

		goto send_message;

	}



	if (test_bit(RXRPC_CALL_ABORT, &call->events)) {

	if (test_bit(RXRPC_CALL_EV_ABORT, &call->events)) {

		ASSERTCMP(call->state, >, RXRPC_CALL_COMPLETE);



		if (rxrpc_post_message(call, RXRPC_SKB_MARK_LOCAL_ERROR,
@@ -981,12 +981,12 @@ void rxrpc_process_call(struct work_struct *work) 
		data = htonl(call->abort_code);

		iov[1].iov_base = &data;

		iov[1].iov_len = sizeof(data);

		genbit = RXRPC_CALL_ABORT;

		genbit = RXRPC_CALL_EV_ABORT;

		goto send_message;

	}



	if (test_bit(RXRPC_CALL_ACK_FINAL, &call->events)) {

		genbit = RXRPC_CALL_ACK_FINAL;

	if (test_bit(RXRPC_CALL_EV_ACK_FINAL, &call->events)) {

		genbit = RXRPC_CALL_EV_ACK_FINAL;



		ack.bufferSpace	= htons(8);

		ack.maxSkew	= 0;
@@ -1012,12 +1012,12 @@ void rxrpc_process_call(struct work_struct *work) 
		goto send_ACK;

	}



	if (call->events & ((1 << RXRPC_CALL_RCVD_BUSY) |

			    (1 << RXRPC_CALL_RCVD_ABORT))

	if (call->events & ((1 << RXRPC_CALL_EV_RCVD_BUSY) |

			    (1 << RXRPC_CALL_EV_RCVD_ABORT))

	    ) {

		u32 mark;



		if (test_bit(RXRPC_CALL_RCVD_ABORT, &call->events))

		if (test_bit(RXRPC_CALL_EV_RCVD_ABORT, &call->events))

			mark = RXRPC_SKB_MARK_REMOTE_ABORT;

		else

			mark = RXRPC_SKB_MARK_BUSY;
@@ -1027,22 +1027,22 @@ void rxrpc_process_call(struct work_struct *work) 
		if (rxrpc_post_message(call, mark, ECONNABORTED, true) < 0)

			goto no_mem;



		clear_bit(RXRPC_CALL_RCVD_BUSY, &call->events);

		clear_bit(RXRPC_CALL_RCVD_ABORT, &call->events);

		clear_bit(RXRPC_CALL_EV_RCVD_BUSY, &call->events);

		clear_bit(RXRPC_CALL_EV_RCVD_ABORT, &call->events);

		goto kill_ACKs;

	}



	if (test_and_clear_bit(RXRPC_CALL_RCVD_ACKALL, &call->events)) {

	if (test_and_clear_bit(RXRPC_CALL_EV_RCVD_ACKALL, &call->events)) {

		_debug("do implicit ackall");

		rxrpc_clear_tx_window(call);

	}



	if (test_bit(RXRPC_CALL_LIFE_TIMER, &call->events)) {

	if (test_bit(RXRPC_CALL_EV_LIFE_TIMER, &call->events)) {

		write_lock_bh(&call->state_lock);

		if (call->state <= RXRPC_CALL_COMPLETE) {

			call->state = RXRPC_CALL_LOCALLY_ABORTED;

			call->abort_code = RX_CALL_TIMEOUT;

			set_bit(RXRPC_CALL_ABORT, &call->events);

			set_bit(RXRPC_CALL_EV_ABORT, &call->events);

		}

		write_unlock_bh(&call->state_lock);
@@ -1051,7 +1051,7 @@ void rxrpc_process_call(struct work_struct *work) 
				       ETIME, true) < 0)

			goto no_mem;



		clear_bit(RXRPC_CALL_LIFE_TIMER, &call->events);

		clear_bit(RXRPC_CALL_EV_LIFE_TIMER, &call->events);

		goto kill_ACKs;

	}
@@ -1072,13 +1072,13 @@ void rxrpc_process_call(struct work_struct *work) 
	}



	/* handle resending */

	if (test_and_clear_bit(RXRPC_CALL_RESEND_TIMER, &call->events))

	if (test_and_clear_bit(RXRPC_CALL_EV_RESEND_TIMER, &call->events))

		rxrpc_resend_timer(call);

	if (test_and_clear_bit(RXRPC_CALL_RESEND, &call->events))

	if (test_and_clear_bit(RXRPC_CALL_EV_RESEND, &call->events))

		rxrpc_resend(call);



	/* consider sending an ordinary ACK */

	if (test_bit(RXRPC_CALL_ACK, &call->events)) {

	if (test_bit(RXRPC_CALL_EV_ACK, &call->events)) {

		_debug("send ACK: window: %d - %d { %lx }",

		       call->rx_data_eaten, call->ackr_win_top,

		       call->ackr_window[0]);
@@ -1086,11 +1086,11 @@ void rxrpc_process_call(struct work_struct *work) 
		if (call->state > RXRPC_CALL_SERVER_ACK_REQUEST &&

		    call->ackr_reason != RXRPC_ACK_PING_RESPONSE) {

			/* ACK by sending reply DATA packet in this state */

			clear_bit(RXRPC_CALL_ACK, &call->events);

			clear_bit(RXRPC_CALL_EV_ACK, &call->events);

			goto maybe_reschedule;

		}



		genbit = RXRPC_CALL_ACK;

		genbit = RXRPC_CALL_EV_ACK;



		acks = kzalloc(call->ackr_win_top - call->rx_data_eaten,

			       GFP_NOFS);
@@ -1153,7 +1153,7 @@ void rxrpc_process_call(struct work_struct *work) 


	/* handle completion of security negotiations on an incoming

	 * connection */

	if (test_and_clear_bit(RXRPC_CALL_SECURED, &call->events)) {

	if (test_and_clear_bit(RXRPC_CALL_EV_SECURED, &call->events)) {

		_debug("secured");

		spin_lock_bh(&call->lock);
@@ -1161,7 +1161,7 @@ void rxrpc_process_call(struct work_struct *work) 
			_debug("securing");

			write_lock(&call->conn->lock);

			if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&

			    !test_bit(RXRPC_CALL_RELEASE, &call->events)) {

			    !test_bit(RXRPC_CALL_EV_RELEASE, &call->events)) {

				_debug("not released");

				call->state = RXRPC_CALL_SERVER_ACCEPTING;

				list_move_tail(&call->accept_link,
@@ -1170,39 +1170,39 @@ void rxrpc_process_call(struct work_struct *work) 
			write_unlock(&call->conn->lock);

			read_lock(&call->state_lock);

			if (call->state < RXRPC_CALL_COMPLETE)

				set_bit(RXRPC_CALL_POST_ACCEPT, &call->events);

				set_bit(RXRPC_CALL_EV_POST_ACCEPT, &call->events);

			read_unlock(&call->state_lock);

		}



		spin_unlock_bh(&call->lock);

		if (!test_bit(RXRPC_CALL_POST_ACCEPT, &call->events))

		if (!test_bit(RXRPC_CALL_EV_POST_ACCEPT, &call->events))

			goto maybe_reschedule;

	}



	/* post a notification of an acceptable connection to the app */

	if (test_bit(RXRPC_CALL_POST_ACCEPT, &call->events)) {

	if (test_bit(RXRPC_CALL_EV_POST_ACCEPT, &call->events)) {

		_debug("post accept");

		if (rxrpc_post_message(call, RXRPC_SKB_MARK_NEW_CALL,

				       0, false) < 0)

			goto no_mem;

		clear_bit(RXRPC_CALL_POST_ACCEPT, &call->events);

		clear_bit(RXRPC_CALL_EV_POST_ACCEPT, &call->events);

		goto maybe_reschedule;

	}



	/* handle incoming call acceptance */

	if (test_and_clear_bit(RXRPC_CALL_ACCEPTED, &call->events)) {

	if (test_and_clear_bit(RXRPC_CALL_EV_ACCEPTED, &call->events)) {

		_debug("accepted");

		ASSERTCMP(call->rx_data_post, ==, 0);

		call->rx_data_post = 1;

		read_lock_bh(&call->state_lock);

		if (call->state < RXRPC_CALL_COMPLETE)

			set_bit(RXRPC_CALL_DRAIN_RX_OOS, &call->events);

			set_bit(RXRPC_CALL_EV_DRAIN_RX_OOS, &call->events);

		read_unlock_bh(&call->state_lock);

	}



	/* drain the out of sequence received packet queue into the packet Rx

	 * queue */

	if (test_and_clear_bit(RXRPC_CALL_DRAIN_RX_OOS, &call->events)) {

	if (test_and_clear_bit(RXRPC_CALL_EV_DRAIN_RX_OOS, &call->events)) {

		while (call->rx_data_post == call->rx_first_oos)

			if (rxrpc_drain_rx_oos_queue(call) < 0)

				break;
@@ -1281,12 +1281,12 @@ void rxrpc_process_call(struct work_struct *work) 
	}



	switch (genbit) {

	case RXRPC_CALL_ABORT:

	case RXRPC_CALL_EV_ABORT:

		clear_bit(genbit, &call->events);

		clear_bit(RXRPC_CALL_RCVD_ABORT, &call->events);

		clear_bit(RXRPC_CALL_EV_RCVD_ABORT, &call->events);

		goto kill_ACKs;



	case RXRPC_CALL_ACK_FINAL:

	case RXRPC_CALL_EV_ACK_FINAL:

		write_lock_bh(&call->state_lock);

		if (call->state == RXRPC_CALL_CLIENT_FINAL_ACK)

			call->state = RXRPC_CALL_COMPLETE;
@@ -1311,9 +1311,9 @@ void rxrpc_process_call(struct work_struct *work) 


kill_ACKs:

	del_timer_sync(&call->ack_timer);

	if (test_and_clear_bit(RXRPC_CALL_ACK_FINAL, &call->events))

	if (test_and_clear_bit(RXRPC_CALL_EV_ACK_FINAL, &call->events))

		rxrpc_put_call(call);

	clear_bit(RXRPC_CALL_ACK, &call->events);

	clear_bit(RXRPC_CALL_EV_ACK, &call->events);



maybe_reschedule:

	if (call->events || !skb_queue_empty(&call->rx_queue)) {
@@ -1332,7 +1332,7 @@ void rxrpc_process_call(struct work_struct *work) 


		read_lock_bh(&call->state_lock);

		if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&

		    !test_and_set_bit(RXRPC_CALL_RELEASE, &call->events))

		    !test_and_set_bit(RXRPC_CALL_EV_RELEASE, &call->events))

			rxrpc_queue_call(call);

		read_unlock_bh(&call->state_lock);

	}

net/rxrpc/ar-call.c

+7 −7
Original line number Diff line number Diff line
@@ -452,7 +452,7 @@ struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *rx, 
		read_lock(&call->state_lock);

		switch (call->state) {

		case RXRPC_CALL_LOCALLY_ABORTED:

			if (!test_and_set_bit(RXRPC_CALL_ABORT, &call->events))

			if (!test_and_set_bit(RXRPC_CALL_EV_ABORT, &call->events))

				rxrpc_queue_call(call);

		case RXRPC_CALL_REMOTELY_ABORTED:

			read_unlock(&call->state_lock);
@@ -686,7 +686,7 @@ void rxrpc_release_call(struct rxrpc_call *call) 
		_debug("+++ ABORTING STATE %d +++\n", call->state);

		call->state = RXRPC_CALL_LOCALLY_ABORTED;

		call->abort_code = RX_CALL_DEAD;

		set_bit(RXRPC_CALL_ABORT, &call->events);

		set_bit(RXRPC_CALL_EV_ABORT, &call->events);

		rxrpc_queue_call(call);

	}

	write_unlock(&call->state_lock);
@@ -763,10 +763,10 @@ static void rxrpc_mark_call_released(struct rxrpc_call *call) 
			_debug("abort call %p", call);

			call->state = RXRPC_CALL_LOCALLY_ABORTED;

			call->abort_code = RX_CALL_DEAD;

			if (!test_and_set_bit(RXRPC_CALL_ABORT, &call->events))

			if (!test_and_set_bit(RXRPC_CALL_EV_ABORT, &call->events))

				sched = true;

		}

		if (!test_and_set_bit(RXRPC_CALL_RELEASE, &call->events))

		if (!test_and_set_bit(RXRPC_CALL_EV_RELEASE, &call->events))

			sched = true;

		if (sched)

			rxrpc_queue_call(call);
@@ -975,7 +975,7 @@ static void rxrpc_call_life_expired(unsigned long _call) 
	_enter("{%d}", call->debug_id);

	read_lock_bh(&call->state_lock);

	if (call->state < RXRPC_CALL_COMPLETE) {

		set_bit(RXRPC_CALL_LIFE_TIMER, &call->events);

		set_bit(RXRPC_CALL_EV_LIFE_TIMER, &call->events);

		rxrpc_queue_call(call);

	}

	read_unlock_bh(&call->state_lock);
@@ -995,7 +995,7 @@ static void rxrpc_resend_time_expired(unsigned long _call) 
		return;



	clear_bit(RXRPC_CALL_RUN_RTIMER, &call->flags);

	if (!test_and_set_bit(RXRPC_CALL_RESEND_TIMER, &call->events))

	if (!test_and_set_bit(RXRPC_CALL_EV_RESEND_TIMER, &call->events))

		rxrpc_queue_call(call);

}
@@ -1013,7 +1013,7 @@ static void rxrpc_ack_time_expired(unsigned long _call) 


	read_lock_bh(&call->state_lock);

	if (call->state < RXRPC_CALL_COMPLETE &&

	    !test_and_set_bit(RXRPC_CALL_ACK, &call->events))

	    !test_and_set_bit(RXRPC_CALL_EV_ACK, &call->events))

		rxrpc_queue_call(call);

	read_unlock_bh(&call->state_lock);

}

net/rxrpc/ar-connevent.c

+3 −3
Original line number Diff line number Diff line
@@ -42,9 +42,9 @@ static void rxrpc_abort_calls(struct rxrpc_connection *conn, int state, 
			call->state = state;

			call->abort_code = abort_code;

			if (state == RXRPC_CALL_LOCALLY_ABORTED)

				set_bit(RXRPC_CALL_CONN_ABORT, &call->events);

				set_bit(RXRPC_CALL_EV_CONN_ABORT, &call->events);

			else

				set_bit(RXRPC_CALL_RCVD_ABORT, &call->events);

				set_bit(RXRPC_CALL_EV_RCVD_ABORT, &call->events);

			rxrpc_queue_call(call);

		}

		write_unlock(&call->state_lock);
@@ -132,7 +132,7 @@ static void rxrpc_call_is_secure(struct rxrpc_call *call) 
	if (call) {

		read_lock(&call->state_lock);

		if (call->state < RXRPC_CALL_COMPLETE &&

		    !test_and_set_bit(RXRPC_CALL_SECURED, &call->events))

		    !test_and_set_bit(RXRPC_CALL_EV_SECURED, &call->events))

			rxrpc_queue_call(call);

		read_unlock(&call->state_lock);

	}

net/rxrpc/ar-error.c

+1 −1
Original line number Diff line number Diff line
@@ -222,7 +222,7 @@ void rxrpc_UDP_error_handler(struct work_struct *work) 
			if (call->state != RXRPC_CALL_COMPLETE &&

			    call->state < RXRPC_CALL_NETWORK_ERROR) {

				call->state = RXRPC_CALL_NETWORK_ERROR;

				set_bit(RXRPC_CALL_RCVD_ERROR, &call->events);

				set_bit(RXRPC_CALL_EV_RCVD_ERROR, &call->events);

				rxrpc_queue_call(call);

			}

			write_unlock(&call->state_lock);