Commit 41adafa0 authored by Trond Myklebust's avatar Trond Myklebust
Browse files

Merge branch 'bh-remove'

parents a332518f c049f8ea

include/linux/sunrpc/sched.h

+2 −1
Original line number Diff line number Diff line
@@ -183,8 +183,9 @@ struct rpc_task_setup { 
#define RPC_NR_PRIORITY		(1 + RPC_PRIORITY_PRIVILEGED - RPC_PRIORITY_LOW)



struct rpc_timer {

	struct timer_list timer;

	struct list_head list;

	unsigned long expires;

	struct delayed_work dwork;

};



/*

include/linux/sunrpc/xprtsock.h

+5 −0
Original line number Diff line number Diff line
@@ -56,6 +56,7 @@ struct sock_xprt { 
	 */

	unsigned long		sock_state;

	struct delayed_work	connect_worker;

	struct work_struct	error_worker;

	struct work_struct	recv_worker;

	struct mutex		recv_mutex;

	struct sockaddr_storage	srcaddr;
@@ -84,6 +85,10 @@ struct sock_xprt { 
#define XPRT_SOCK_CONNECTING	1U

#define XPRT_SOCK_DATA_READY	(2)

#define XPRT_SOCK_UPD_TIMEOUT	(3)

#define XPRT_SOCK_WAKE_ERROR	(4)

#define XPRT_SOCK_WAKE_WRITE	(5)

#define XPRT_SOCK_WAKE_PENDING	(6)

#define XPRT_SOCK_WAKE_DISCONNECT	(7)



#endif /* __KERNEL__ */

net/sunrpc/sched.c

+41 −31
Original line number Diff line number Diff line
@@ -47,7 +47,7 @@ static mempool_t *rpc_buffer_mempool __read_mostly; 


static void			rpc_async_schedule(struct work_struct *);

static void			 rpc_release_task(struct rpc_task *task);

static void __rpc_queue_timer_fn(struct timer_list *t);

static void __rpc_queue_timer_fn(struct work_struct *);



/*

 * RPC tasks sit here while waiting for conditions to improve.
@@ -88,13 +88,19 @@ __rpc_disable_timer(struct rpc_wait_queue *queue, struct rpc_task *task) 
	task->tk_timeout = 0;

	list_del(&task->u.tk_wait.timer_list);

	if (list_empty(&queue->timer_list.list))

		del_timer(&queue->timer_list.timer);

		cancel_delayed_work(&queue->timer_list.dwork);

}



static void

rpc_set_queue_timer(struct rpc_wait_queue *queue, unsigned long expires)

{

	timer_reduce(&queue->timer_list.timer, expires);

	unsigned long now = jiffies;

	queue->timer_list.expires = expires;

	if (time_before_eq(expires, now))

		expires = 0;

	else

		expires -= now;

	mod_delayed_work(rpciod_workqueue, &queue->timer_list.dwork, expires);

}



/*
@@ -108,6 +114,7 @@ __rpc_add_timer(struct rpc_wait_queue *queue, struct rpc_task *task, 
		task->tk_pid, jiffies_to_msecs(timeout - jiffies));



	task->tk_timeout = timeout;

	if (list_empty(&queue->timer_list.list) || time_before(timeout, queue->timer_list.expires))

		rpc_set_queue_timer(queue, timeout);

	list_add(&task->u.tk_wait.timer_list, &queue->timer_list.list);

}
@@ -251,7 +258,8 @@ static void __rpc_init_priority_wait_queue(struct rpc_wait_queue *queue, const c 
	queue->maxpriority = nr_queues - 1;

	rpc_reset_waitqueue_priority(queue);

	queue->qlen = 0;

	timer_setup(&queue->timer_list.timer, __rpc_queue_timer_fn, 0);

	queue->timer_list.expires = 0;

	INIT_DEFERRABLE_WORK(&queue->timer_list.dwork, __rpc_queue_timer_fn);

	INIT_LIST_HEAD(&queue->timer_list.list);

	rpc_assign_waitqueue_name(queue, qname);

}
@@ -270,7 +278,7 @@ EXPORT_SYMBOL_GPL(rpc_init_wait_queue); 


void rpc_destroy_wait_queue(struct rpc_wait_queue *queue)

{

	del_timer_sync(&queue->timer_list.timer);

	cancel_delayed_work_sync(&queue->timer_list.dwork);

}

EXPORT_SYMBOL_GPL(rpc_destroy_wait_queue);
@@ -425,9 +433,9 @@ void rpc_sleep_on_timeout(struct rpc_wait_queue *q, struct rpc_task *task, 
	/*

	 * Protect the queue operations.

	 */

	spin_lock_bh(&q->lock);

	spin_lock(&q->lock);

	__rpc_sleep_on_priority_timeout(q, task, timeout, task->tk_priority);

	spin_unlock_bh(&q->lock);

	spin_unlock(&q->lock);

}

EXPORT_SYMBOL_GPL(rpc_sleep_on_timeout);
@@ -443,9 +451,9 @@ void rpc_sleep_on(struct rpc_wait_queue *q, struct rpc_task *task, 
	/*

	 * Protect the queue operations.

	 */

	spin_lock_bh(&q->lock);

	spin_lock(&q->lock);

	__rpc_sleep_on_priority(q, task, task->tk_priority);

	spin_unlock_bh(&q->lock);

	spin_unlock(&q->lock);

}

EXPORT_SYMBOL_GPL(rpc_sleep_on);
@@ -459,9 +467,9 @@ void rpc_sleep_on_priority_timeout(struct rpc_wait_queue *q, 
	/*

	 * Protect the queue operations.

	 */

	spin_lock_bh(&q->lock);

	spin_lock(&q->lock);

	__rpc_sleep_on_priority_timeout(q, task, timeout, priority);

	spin_unlock_bh(&q->lock);

	spin_unlock(&q->lock);

}

EXPORT_SYMBOL_GPL(rpc_sleep_on_priority_timeout);
@@ -476,9 +484,9 @@ void rpc_sleep_on_priority(struct rpc_wait_queue *q, struct rpc_task *task, 
	/*

	 * Protect the queue operations.

	 */

	spin_lock_bh(&q->lock);

	spin_lock(&q->lock);

	__rpc_sleep_on_priority(q, task, priority);

	spin_unlock_bh(&q->lock);

	spin_unlock(&q->lock);

}

EXPORT_SYMBOL_GPL(rpc_sleep_on_priority);
@@ -556,9 +564,9 @@ void rpc_wake_up_queued_task_on_wq(struct workqueue_struct *wq, 
{

	if (!RPC_IS_QUEUED(task))

		return;

	spin_lock_bh(&queue->lock);

	spin_lock(&queue->lock);

	rpc_wake_up_task_on_wq_queue_locked(wq, queue, task);

	spin_unlock_bh(&queue->lock);

	spin_unlock(&queue->lock);

}



/*
@@ -568,9 +576,9 @@ void rpc_wake_up_queued_task(struct rpc_wait_queue *queue, struct rpc_task *task 
{

	if (!RPC_IS_QUEUED(task))

		return;

	spin_lock_bh(&queue->lock);

	spin_lock(&queue->lock);

	rpc_wake_up_task_queue_locked(queue, task);

	spin_unlock_bh(&queue->lock);

	spin_unlock(&queue->lock);

}

EXPORT_SYMBOL_GPL(rpc_wake_up_queued_task);
@@ -603,9 +611,9 @@ rpc_wake_up_queued_task_set_status(struct rpc_wait_queue *queue, 
{

	if (!RPC_IS_QUEUED(task))

		return;

	spin_lock_bh(&queue->lock);

	spin_lock(&queue->lock);

	rpc_wake_up_task_queue_set_status_locked(queue, task, status);

	spin_unlock_bh(&queue->lock);

	spin_unlock(&queue->lock);

}



/*
@@ -668,12 +676,12 @@ struct rpc_task *rpc_wake_up_first_on_wq(struct workqueue_struct *wq, 


	dprintk("RPC:       wake_up_first(%p \"%s\")\n",

			queue, rpc_qname(queue));

	spin_lock_bh(&queue->lock);

	spin_lock(&queue->lock);

	task = __rpc_find_next_queued(queue);

	if (task != NULL)

		task = rpc_wake_up_task_on_wq_queue_action_locked(wq, queue,

				task, func, data);

	spin_unlock_bh(&queue->lock);

	spin_unlock(&queue->lock);



	return task;

}
@@ -712,7 +720,7 @@ void rpc_wake_up(struct rpc_wait_queue *queue) 
{

	struct list_head *head;



	spin_lock_bh(&queue->lock);

	spin_lock(&queue->lock);

	head = &queue->tasks[queue->maxpriority];

	for (;;) {

		while (!list_empty(head)) {
@@ -726,7 +734,7 @@ void rpc_wake_up(struct rpc_wait_queue *queue) 
			break;

		head--;

	}

	spin_unlock_bh(&queue->lock);

	spin_unlock(&queue->lock);

}

EXPORT_SYMBOL_GPL(rpc_wake_up);
@@ -741,7 +749,7 @@ void rpc_wake_up_status(struct rpc_wait_queue *queue, int status) 
{

	struct list_head *head;



	spin_lock_bh(&queue->lock);

	spin_lock(&queue->lock);

	head = &queue->tasks[queue->maxpriority];

	for (;;) {

		while (!list_empty(head)) {
@@ -756,13 +764,15 @@ void rpc_wake_up_status(struct rpc_wait_queue *queue, int status) 
			break;

		head--;

	}

	spin_unlock_bh(&queue->lock);

	spin_unlock(&queue->lock);

}

EXPORT_SYMBOL_GPL(rpc_wake_up_status);



static void __rpc_queue_timer_fn(struct timer_list *t)

static void __rpc_queue_timer_fn(struct work_struct *work)

{

	struct rpc_wait_queue *queue = from_timer(queue, t, timer_list.timer);

	struct rpc_wait_queue *queue = container_of(work,

			struct rpc_wait_queue,

			timer_list.dwork.work);

	struct rpc_task *task, *n;

	unsigned long expires, now, timeo;
@@ -932,13 +942,13 @@ static void __rpc_execute(struct rpc_task *task) 
		 * rpc_task pointer may still be dereferenced.

		 */

		queue = task->tk_waitqueue;

		spin_lock_bh(&queue->lock);

		spin_lock(&queue->lock);

		if (!RPC_IS_QUEUED(task)) {

			spin_unlock_bh(&queue->lock);

			spin_unlock(&queue->lock);

			continue;

		}

		rpc_clear_running(task);

		spin_unlock_bh(&queue->lock);

		spin_unlock(&queue->lock);

		if (task_is_async)

			return;

net/sunrpc/xprt.c

+28 −33
Original line number Diff line number Diff line
@@ -302,9 +302,9 @@ static inline int xprt_lock_write(struct rpc_xprt *xprt, struct rpc_task *task) 


	if (test_bit(XPRT_LOCKED, &xprt->state) && xprt->snd_task == task)

		return 1;

	spin_lock_bh(&xprt->transport_lock);

	spin_lock(&xprt->transport_lock);

	retval = xprt->ops->reserve_xprt(xprt, task);

	spin_unlock_bh(&xprt->transport_lock);

	spin_unlock(&xprt->transport_lock);

	return retval;

}
@@ -381,9 +381,9 @@ static inline void xprt_release_write(struct rpc_xprt *xprt, struct rpc_task *ta 
{

	if (xprt->snd_task != task)

		return;

	spin_lock_bh(&xprt->transport_lock);

	spin_lock(&xprt->transport_lock);

	xprt->ops->release_xprt(xprt, task);

	spin_unlock_bh(&xprt->transport_lock);

	spin_unlock(&xprt->transport_lock);

}



/*
@@ -435,9 +435,9 @@ xprt_request_get_cong(struct rpc_xprt *xprt, struct rpc_rqst *req) 


	if (req->rq_cong)

		return true;

	spin_lock_bh(&xprt->transport_lock);

	spin_lock(&xprt->transport_lock);

	ret = __xprt_get_cong(xprt, req) != 0;

	spin_unlock_bh(&xprt->transport_lock);

	spin_unlock(&xprt->transport_lock);

	return ret;

}

EXPORT_SYMBOL_GPL(xprt_request_get_cong);
@@ -464,9 +464,9 @@ static void 
xprt_clear_congestion_window_wait(struct rpc_xprt *xprt)

{

	if (test_and_clear_bit(XPRT_CWND_WAIT, &xprt->state)) {

		spin_lock_bh(&xprt->transport_lock);

		spin_lock(&xprt->transport_lock);

		__xprt_lock_write_next_cong(xprt);

		spin_unlock_bh(&xprt->transport_lock);

		spin_unlock(&xprt->transport_lock);

	}

}
@@ -563,9 +563,9 @@ bool xprt_write_space(struct rpc_xprt *xprt) 


	if (!test_bit(XPRT_WRITE_SPACE, &xprt->state))

		return false;

	spin_lock_bh(&xprt->transport_lock);

	spin_lock(&xprt->transport_lock);

	ret = xprt_clear_write_space_locked(xprt);

	spin_unlock_bh(&xprt->transport_lock);

	spin_unlock(&xprt->transport_lock);

	return ret;

}

EXPORT_SYMBOL_GPL(xprt_write_space);
@@ -634,9 +634,9 @@ int xprt_adjust_timeout(struct rpc_rqst *req) 
		req->rq_retries = 0;

		xprt_reset_majortimeo(req);

		/* Reset the RTT counters == "slow start" */

		spin_lock_bh(&xprt->transport_lock);

		spin_lock(&xprt->transport_lock);

		rpc_init_rtt(req->rq_task->tk_client->cl_rtt, to->to_initval);

		spin_unlock_bh(&xprt->transport_lock);

		spin_unlock(&xprt->transport_lock);

		status = -ETIMEDOUT;

	}
@@ -668,11 +668,11 @@ static void xprt_autoclose(struct work_struct *work) 
void xprt_disconnect_done(struct rpc_xprt *xprt)

{

	dprintk("RPC:       disconnected transport %p\n", xprt);

	spin_lock_bh(&xprt->transport_lock);

	spin_lock(&xprt->transport_lock);

	xprt_clear_connected(xprt);

	xprt_clear_write_space_locked(xprt);

	xprt_wake_pending_tasks(xprt, -ENOTCONN);

	spin_unlock_bh(&xprt->transport_lock);

	spin_unlock(&xprt->transport_lock);

}

EXPORT_SYMBOL_GPL(xprt_disconnect_done);
@@ -684,7 +684,7 @@ EXPORT_SYMBOL_GPL(xprt_disconnect_done); 
void xprt_force_disconnect(struct rpc_xprt *xprt)

{

	/* Don't race with the test_bit() in xprt_clear_locked() */

	spin_lock_bh(&xprt->transport_lock);

	spin_lock(&xprt->transport_lock);

	set_bit(XPRT_CLOSE_WAIT, &xprt->state);

	/* Try to schedule an autoclose RPC call */

	if (test_and_set_bit(XPRT_LOCKED, &xprt->state) == 0)
@@ -692,7 +692,7 @@ void xprt_force_disconnect(struct rpc_xprt *xprt) 
	else if (xprt->snd_task)

		rpc_wake_up_queued_task_set_status(&xprt->pending,

				xprt->snd_task, -ENOTCONN);

	spin_unlock_bh(&xprt->transport_lock);

	spin_unlock(&xprt->transport_lock);

}

EXPORT_SYMBOL_GPL(xprt_force_disconnect);
@@ -726,7 +726,7 @@ xprt_request_retransmit_after_disconnect(struct rpc_task *task) 
void xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie)

{

	/* Don't race with the test_bit() in xprt_clear_locked() */

	spin_lock_bh(&xprt->transport_lock);

	spin_lock(&xprt->transport_lock);

	if (cookie != xprt->connect_cookie)

		goto out;

	if (test_bit(XPRT_CLOSING, &xprt->state))
@@ -737,7 +737,7 @@ void xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie) 
		queue_work(xprtiod_workqueue, &xprt->task_cleanup);

	xprt_wake_pending_tasks(xprt, -EAGAIN);

out:

	spin_unlock_bh(&xprt->transport_lock);

	spin_unlock(&xprt->transport_lock);

}



static bool
@@ -759,18 +759,13 @@ xprt_init_autodisconnect(struct timer_list *t) 
{

	struct rpc_xprt *xprt = from_timer(xprt, t, timer);



	spin_lock(&xprt->transport_lock);

	if (!RB_EMPTY_ROOT(&xprt->recv_queue))

		goto out_abort;

		return;

	/* Reset xprt->last_used to avoid connect/autodisconnect cycling */

	xprt->last_used = jiffies;

	if (test_and_set_bit(XPRT_LOCKED, &xprt->state))

		goto out_abort;

	spin_unlock(&xprt->transport_lock);

	queue_work(xprtiod_workqueue, &xprt->task_cleanup);

		return;

out_abort:

	spin_unlock(&xprt->transport_lock);

	queue_work(xprtiod_workqueue, &xprt->task_cleanup);

}



bool xprt_lock_connect(struct rpc_xprt *xprt,
@@ -779,7 +774,7 @@ bool xprt_lock_connect(struct rpc_xprt *xprt, 
{

	bool ret = false;



	spin_lock_bh(&xprt->transport_lock);

	spin_lock(&xprt->transport_lock);

	if (!test_bit(XPRT_LOCKED, &xprt->state))

		goto out;

	if (xprt->snd_task != task)
@@ -787,13 +782,13 @@ bool xprt_lock_connect(struct rpc_xprt *xprt, 
	xprt->snd_task = cookie;

	ret = true;

out:

	spin_unlock_bh(&xprt->transport_lock);

	spin_unlock(&xprt->transport_lock);

	return ret;

}



void xprt_unlock_connect(struct rpc_xprt *xprt, void *cookie)

{

	spin_lock_bh(&xprt->transport_lock);

	spin_lock(&xprt->transport_lock);

	if (xprt->snd_task != cookie)

		goto out;

	if (!test_bit(XPRT_LOCKED, &xprt->state))
@@ -802,7 +797,7 @@ void xprt_unlock_connect(struct rpc_xprt *xprt, void *cookie) 
	xprt->ops->release_xprt(xprt, NULL);

	xprt_schedule_autodisconnect(xprt);

out:

	spin_unlock_bh(&xprt->transport_lock);

	spin_unlock(&xprt->transport_lock);

	wake_up_bit(&xprt->state, XPRT_LOCKED);

}
@@ -1412,14 +1407,14 @@ xprt_request_transmit(struct rpc_rqst *req, struct rpc_task *snd_task) 
	xprt_inject_disconnect(xprt);



	task->tk_flags |= RPC_TASK_SENT;

	spin_lock_bh(&xprt->transport_lock);

	spin_lock(&xprt->transport_lock);



	xprt->stat.sends++;

	xprt->stat.req_u += xprt->stat.sends - xprt->stat.recvs;

	xprt->stat.bklog_u += xprt->backlog.qlen;

	xprt->stat.sending_u += xprt->sending.qlen;

	xprt->stat.pending_u += xprt->pending.qlen;

	spin_unlock_bh(&xprt->transport_lock);

	spin_unlock(&xprt->transport_lock);



	req->rq_connect_cookie = connect_cookie;

out_dequeue:
@@ -1766,13 +1761,13 @@ void xprt_release(struct rpc_task *task) 


	xprt = req->rq_xprt;

	xprt_request_dequeue_all(task, req);

	spin_lock_bh(&xprt->transport_lock);

	spin_lock(&xprt->transport_lock);

	xprt->ops->release_xprt(xprt, task);

	if (xprt->ops->release_request)

		xprt->ops->release_request(task);

	xprt->last_used = jiffies;

	xprt_schedule_autodisconnect(xprt);

	spin_unlock_bh(&xprt->transport_lock);

	spin_unlock(&xprt->transport_lock);

	if (req->rq_buffer)

		xprt->ops->buf_free(task);

	xprt_inject_disconnect(xprt);

net/sunrpc/xprtrdma/rpc_rdma.c

+2 −2
Original line number Diff line number Diff line
@@ -1360,10 +1360,10 @@ void rpcrdma_reply_handler(struct rpcrdma_rep *rep) 
	else if (credits > buf->rb_max_requests)

		credits = buf->rb_max_requests;

	if (buf->rb_credits != credits) {

		spin_lock_bh(&xprt->transport_lock);

		spin_lock(&xprt->transport_lock);

		buf->rb_credits = credits;

		xprt->cwnd = credits << RPC_CWNDSHIFT;

		spin_unlock_bh(&xprt->transport_lock);

		spin_unlock(&xprt->transport_lock);

	}



	req = rpcr_to_rdmar(rqst);

CRA Git | Maintained and supported by SUSTech CRA and CCSE