[linux-2.6-block.git] / net / rxrpc / krxtimod.c

/* krxtimod.c: RXRPC timeout daemon
 *
 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/completion.h>
#include <linux/freezer.h>
#include <rxrpc/rxrpc.h>
#include <rxrpc/krxtimod.h>
#include <asm/errno.h>
#include "internal.h"

static DECLARE_COMPLETION(krxtimod_alive);
static DECLARE_COMPLETION(krxtimod_dead);
static DECLARE_WAIT_QUEUE_HEAD(krxtimod_sleepq);
static int krxtimod_die;

static LIST_HEAD(krxtimod_list);
static DEFINE_SPINLOCK(krxtimod_lock);

static int krxtimod(void *arg);

/*****************************************************************************/
/*
 * start the timeout daemon
 */
int rxrpc_krxtimod_start(void)
{
	int ret;

	ret = kernel_thread(krxtimod, NULL, 0);
	if (ret < 0)
		return ret;

	wait_for_completion(&krxtimod_alive);

	return ret;
} /* end rxrpc_krxtimod_start() */

/*****************************************************************************/
/*
 * stop the timeout daemon
 */
void rxrpc_krxtimod_kill(void)
{
	/* get rid of my daemon */
	krxtimod_die = 1;
	wake_up(&krxtimod_sleepq);
	wait_for_completion(&krxtimod_dead);

} /* end rxrpc_krxtimod_kill() */

/*****************************************************************************/
/*
 * timeout processing daemon
 */
static int krxtimod(void *arg)
{
	DECLARE_WAITQUEUE(myself, current);

	rxrpc_timer_t *timer;

	printk("Started krxtimod %d\n", current->pid);

	daemonize("krxtimod");

	complete(&krxtimod_alive);

	/* loop around looking for things to attend to */
 loop:
	set_current_state(TASK_INTERRUPTIBLE);
	add_wait_queue(&krxtimod_sleepq, &myself);

	for (;;) {
		unsigned long jif;
		long timeout;

		/* deal with the server being asked to die */
		if (krxtimod_die) {
			remove_wait_queue(&krxtimod_sleepq, &myself);
			_leave("");
			complete_and_exit(&krxtimod_dead, 0);
		}

		try_to_freeze();

		/* discard pending signals */
		rxrpc_discard_my_signals();

		/* work out the time to elapse before the next event */
		spin_lock(&krxtimod_lock);
		if (list_empty(&krxtimod_list)) {
			timeout = MAX_SCHEDULE_TIMEOUT;
		}
		else {
			timer = list_entry(krxtimod_list.next,
					   rxrpc_timer_t, link);
			timeout = timer->timo_jif;
			jif = jiffies;

			if (time_before_eq((unsigned long) timeout, jif))
				goto immediate;

			else {
				timeout = (long) timeout - (long) jiffies;
			}
		}
		spin_unlock(&krxtimod_lock);

		schedule_timeout(timeout);

		set_current_state(TASK_INTERRUPTIBLE);
	}

	/* the thing on the front of the queue needs processing
	 * - we come here with the lock held and timer pointing to the expired
	 *   entry
	 */
 immediate:
	remove_wait_queue(&krxtimod_sleepq, &myself);
	set_current_state(TASK_RUNNING);

	_debug("@@@ Begin Timeout of %p", timer);

	/* dequeue the timer */
	list_del_init(&timer->link);
	spin_unlock(&krxtimod_lock);

	/* call the timeout function */
	timer->ops->timed_out(timer);

	_debug("@@@ End Timeout");
	goto loop;

} /* end krxtimod() */

/*****************************************************************************/
/*
 * (re-)queue a timer
 */
void rxrpc_krxtimod_add_timer(rxrpc_timer_t *timer, unsigned long timeout)
{
	struct list_head *_p;
	rxrpc_timer_t *ptimer;

	_enter("%p,%lu", timer, timeout);

	spin_lock(&krxtimod_lock);

	list_del(&timer->link);

	/* the timer was deferred or reset - put it back in the queue at the
	 * right place */
	timer->timo_jif = jiffies + timeout;

	list_for_each(_p, &krxtimod_list) {
		ptimer = list_entry(_p, rxrpc_timer_t, link);
		if (time_before(timer->timo_jif, ptimer->timo_jif))
			break;
	}

	list_add_tail(&timer->link, _p); /* insert before stopping point */

	spin_unlock(&krxtimod_lock);

	wake_up(&krxtimod_sleepq);

	_leave("");
} /* end rxrpc_krxtimod_add_timer() */

/*****************************************************************************/
/*
 * dequeue a timer
 * - returns 0 if the timer was deleted or -ENOENT if it wasn't queued
 */
int rxrpc_krxtimod_del_timer(rxrpc_timer_t *timer)
{
	int ret = 0;

	_enter("%p", timer);

	spin_lock(&krxtimod_lock);

	if (list_empty(&timer->link))
		ret = -ENOENT;
	else
		list_del_init(&timer->link);

	spin_unlock(&krxtimod_lock);

	wake_up(&krxtimod_sleepq);

	_leave(" = %d", ret);
	return ret;
} /* end rxrpc_krxtimod_del_timer() */
Commit	Line	Data
1da177e4 LT	1	/* krxtimod.c: RXRPC timeout daemon
	2	*
	3	* Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells (dhowells@redhat.com)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/init.h>
	14	#include <linux/sched.h>
	15	#include <linux/completion.h>
7dfb7103	16	#include <linux/freezer.h>
1da177e4 LT	17	#include <rxrpc/rxrpc.h>
	18	#include <rxrpc/krxtimod.h>
	19	#include <asm/errno.h>
	20	#include "internal.h"
	21
	22	static DECLARE_COMPLETION(krxtimod_alive);
	23	static DECLARE_COMPLETION(krxtimod_dead);
	24	static DECLARE_WAIT_QUEUE_HEAD(krxtimod_sleepq);
	25	static int krxtimod_die;
	26
	27	static LIST_HEAD(krxtimod_list);
	28	static DEFINE_SPINLOCK(krxtimod_lock);
	29
	30	static int krxtimod(void *arg);
	31
	32	/*****************************************************************************/
	33	/*
	34	* start the timeout daemon
	35	*/
	36	int rxrpc_krxtimod_start(void)
	37	{
	38	int ret;
	39
	40	ret = kernel_thread(krxtimod, NULL, 0);
	41	if (ret < 0)
	42	return ret;
	43
	44	wait_for_completion(&krxtimod_alive);
	45
	46	return ret;
	47	} /* end rxrpc_krxtimod_start() */
	48
	49	/*****************************************************************************/
	50	/*
	51	* stop the timeout daemon
	52	*/
	53	void rxrpc_krxtimod_kill(void)
	54	{
	55	/* get rid of my daemon */
	56	krxtimod_die = 1;
	57	wake_up(&krxtimod_sleepq);
	58	wait_for_completion(&krxtimod_dead);
	59
	60	} /* end rxrpc_krxtimod_kill() */
	61
	62	/*****************************************************************************/
	63	/*
	64	* timeout processing daemon
	65	*/
	66	static int krxtimod(void *arg)
	67	{
	68	DECLARE_WAITQUEUE(myself, current);
	69
	70	rxrpc_timer_t *timer;
	71
	72	printk("Started krxtimod %d\n", current->pid);
	73
	74	daemonize("krxtimod");
	75
	76	complete(&krxtimod_alive);
	77
	78	/* loop around looking for things to attend to */
	79	loop:
	80	set_current_state(TASK_INTERRUPTIBLE);
81	add_wait_queue(&krxtimod_sleepq, &myself);
82
83	for (;;) {
84	unsigned long jif;
a8fc3d8d	85	long timeout;
1da177e4 LT	86
	87	/* deal with the server being asked to die */
	88	if (krxtimod_die) {
	89	remove_wait_queue(&krxtimod_sleepq, &myself);
	90	_leave("");
	91	complete_and_exit(&krxtimod_dead, 0);
	92	}
	93
3e1d1d28	94	try_to_freeze();
1da177e4 LT	95
	96	/* discard pending signals */
	97	rxrpc_discard_my_signals();
	98
	99	/* work out the time to elapse before the next event */
	100	spin_lock(&krxtimod_lock);
	101	if (list_empty(&krxtimod_list)) {
	102	timeout = MAX_SCHEDULE_TIMEOUT;
	103	}
	104	else {
	105	timer = list_entry(krxtimod_list.next,
	106	rxrpc_timer_t, link);
	107	timeout = timer->timo_jif;
	108	jif = jiffies;
	109
	110	if (time_before_eq((unsigned long) timeout, jif))
	111	goto immediate;
	112
	113	else {
	114	timeout = (long) timeout - (long) jiffies;
	115	}
	116	}
	117	spin_unlock(&krxtimod_lock);
	118
	119	schedule_timeout(timeout);
	120
	121	set_current_state(TASK_INTERRUPTIBLE);
	122	}
	123
	124	/* the thing on the front of the queue needs processing
	125	* - we come here with the lock held and timer pointing to the expired
	126	* entry
	127	*/
	128	immediate:
	129	remove_wait_queue(&krxtimod_sleepq, &myself);
	130	set_current_state(TASK_RUNNING);
	131
	132	_debug("@@@ Begin Timeout of %p", timer);
	133
	134	/* dequeue the timer */
	135	list_del_init(&timer->link);
	136	spin_unlock(&krxtimod_lock);
	137
	138	/* call the timeout function */
	139	timer->ops->timed_out(timer);
	140
	141	_debug("@@@ End Timeout");
	142	goto loop;
	143
	144	} /* end krxtimod() */
	145
	146	/*****************************************************************************/
	147	/*
	148	* (re-)queue a timer
	149	*/
	150	void rxrpc_krxtimod_add_timer(rxrpc_timer_t *timer, unsigned long timeout)
	151	{
	152	struct list_head *_p;
	153	rxrpc_timer_t *ptimer;
	154
	155	_enter("%p,%lu", timer, timeout);
	156
	157	spin_lock(&krxtimod_lock);
	158
159	list_del(&timer->link);
160
161	/* the timer was deferred or reset - put it back in the queue at the
162	* right place */
163	timer->timo_jif = jiffies + timeout;
164
165	list_for_each(_p, &krxtimod_list) {
166	ptimer = list_entry(_p, rxrpc_timer_t, link);
167	if (time_before(timer->timo_jif, ptimer->timo_jif))
168	break;
169	}
170
171	list_add_tail(&timer->link, _p); /* insert before stopping point */
172
173	spin_unlock(&krxtimod_lock);
174
175	wake_up(&krxtimod_sleepq);
176
177	_leave("");
178	} /* end rxrpc_krxtimod_add_timer() */
179
180	/*****************************************************************************/
181	/*
182	* dequeue a timer
183	* - returns 0 if the timer was deleted or -ENOENT if it wasn't queued
184	*/
185	int rxrpc_krxtimod_del_timer(rxrpc_timer_t *timer)
186	{
187	int ret = 0;
188
189	_enter("%p", timer);
190
191	spin_lock(&krxtimod_lock);
192
193	if (list_empty(&timer->link))
194	ret = -ENOENT;
195	else
196	list_del_init(&timer->link);
197
198	spin_unlock(&krxtimod_lock);
199
200	wake_up(&krxtimod_sleepq);
201
202	_leave(" = %d", ret);
203	return ret;
204	} /* end rxrpc_krxtimod_del_timer() */