[linux.git] / fs / afs / callback.c

/*
 * Copyright (c) 2002 Red Hat, Inc. All rights reserved.
 *
 * This software may be freely redistributed under the terms of the
 * GNU General Public License.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * Authors: David Woodhouse <[email protected]>
 *          David Howells <[email protected]>
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include "server.h"
#include "vnode.h"
#include "internal.h"

/*****************************************************************************/
/*
 * allow the fileserver to request callback state (re-)initialisation
 */
int SRXAFSCM_InitCallBackState(struct afs_server *server)
{
	struct list_head callbacks;

	_enter("%p", server);

	INIT_LIST_HEAD(&callbacks);

	/* transfer the callback list from the server to a temp holding area */
	spin_lock(&server->cb_lock);

	list_add(&callbacks, &server->cb_promises);
	list_del_init(&server->cb_promises);

	/* munch our way through the list, grabbing the inode, dropping all the
	 * locks and regetting them in the right order
	 */
	while (!list_empty(&callbacks)) {
		struct afs_vnode *vnode;
		struct inode *inode;

		vnode = list_entry(callbacks.next, struct afs_vnode, cb_link);
		list_del_init(&vnode->cb_link);

		/* try and grab the inode - may fail */
		inode = igrab(AFS_VNODE_TO_I(vnode));
		if (inode) {
			int release = 0;

			spin_unlock(&server->cb_lock);
			spin_lock(&vnode->lock);

			if (vnode->cb_server == server) {
				vnode->cb_server = NULL;
				afs_kafstimod_del_timer(&vnode->cb_timeout);
				spin_lock(&afs_cb_hash_lock);
				list_del_init(&vnode->cb_hash_link);
				spin_unlock(&afs_cb_hash_lock);
				release = 1;
			}

			spin_unlock(&vnode->lock);

			iput(inode);
			afs_put_server(server);

			spin_lock(&server->cb_lock);
		}
	}

	spin_unlock(&server->cb_lock);

	_leave(" = 0");
	return 0;
} /* end SRXAFSCM_InitCallBackState() */

/*****************************************************************************/
/*
 * allow the fileserver to break callback promises
 */
int SRXAFSCM_CallBack(struct afs_server *server, size_t count,
		      struct afs_callback callbacks[])
{
	_enter("%p,%u,", server, count);

	for (; count > 0; callbacks++, count--) {
		struct afs_vnode *vnode = NULL;
		struct inode *inode = NULL;
		int valid = 0;

		_debug("- Fid { vl=%08x n=%u u=%u }  CB { v=%u x=%u t=%u }",
		       callbacks->fid.vid,
		       callbacks->fid.vnode,
		       callbacks->fid.unique,
		       callbacks->version,
		       callbacks->expiry,
		       callbacks->type
		       );

		/* find the inode for this fid */
		spin_lock(&afs_cb_hash_lock);

		list_for_each_entry(vnode,
				    &afs_cb_hash(server, &callbacks->fid),
				    cb_hash_link) {
			if (memcmp(&vnode->fid, &callbacks->fid,
				   sizeof(struct afs_fid)) != 0)
				continue;

			/* right vnode, but is it same server? */
			if (vnode->cb_server != server)
				break; /* no */

			/* try and nail the inode down */
			inode = igrab(AFS_VNODE_TO_I(vnode));
			break;
		}

		spin_unlock(&afs_cb_hash_lock);

		if (inode) {
			/* we've found the record for this vnode */
			spin_lock(&vnode->lock);
			if (vnode->cb_server == server) {
				/* the callback _is_ on the calling server */
				vnode->cb_server = NULL;
				valid = 1;

				afs_kafstimod_del_timer(&vnode->cb_timeout);
				vnode->flags |= AFS_VNODE_CHANGED;

				spin_lock(&server->cb_lock);
				list_del_init(&vnode->cb_link);
				spin_unlock(&server->cb_lock);

				spin_lock(&afs_cb_hash_lock);
				list_del_init(&vnode->cb_hash_link);
				spin_unlock(&afs_cb_hash_lock);
			}
			spin_unlock(&vnode->lock);

			if (valid) {
				invalidate_remote_inode(inode);
				afs_put_server(server);
			}
			iput(inode);
		}
	}

	_leave(" = 0");
	return 0;
} /* end SRXAFSCM_CallBack() */

/*****************************************************************************/
/*
 * allow the fileserver to see if the cache manager is still alive
 */
int SRXAFSCM_Probe(struct afs_server *server)
{
	_debug("SRXAFSCM_Probe(%p)\n", server);
	return 0;
} /* end SRXAFSCM_Probe() */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright (c) 2002 Red Hat, Inc. All rights reserved.
	3	*
	4	* This software may be freely redistributed under the terms of the
	5	* GNU General Public License.
	6	*
	7	* You should have received a copy of the GNU General Public License
	8	* along with this program; if not, write to the Free Software
	9	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	10	*
	11	* Authors: David Woodhouse <[email protected]>
	12	* David Howells <[email protected]>
	13	*
	14	*/
	15
	16	#include <linux/kernel.h>
	17	#include <linux/module.h>
	18	#include <linux/init.h>
	19	#include "server.h"
	20	#include "vnode.h"
	21	#include "internal.h"
	22
	23	/*****************************************************************************/
	24	/*
	25	* allow the fileserver to request callback state (re-)initialisation
	26	*/
	27	int SRXAFSCM_InitCallBackState(struct afs_server *server)
	28	{
	29	struct list_head callbacks;
	30
	31	_enter("%p", server);
	32
	33	INIT_LIST_HEAD(&callbacks);
	34
	35	/* transfer the callback list from the server to a temp holding area */
	36	spin_lock(&server->cb_lock);
	37
	38	list_add(&callbacks, &server->cb_promises);
	39	list_del_init(&server->cb_promises);
	40
	41	/* munch our way through the list, grabbing the inode, dropping all the
	42	* locks and regetting them in the right order
	43	*/
	44	while (!list_empty(&callbacks)) {
	45	struct afs_vnode *vnode;
	46	struct inode *inode;
	47
	48	vnode = list_entry(callbacks.next, struct afs_vnode, cb_link);
	49	list_del_init(&vnode->cb_link);
	50
	51	/* try and grab the inode - may fail */
	52	inode = igrab(AFS_VNODE_TO_I(vnode));
	53	if (inode) {
	54	int release = 0;
	55
	56	spin_unlock(&server->cb_lock);
	57	spin_lock(&vnode->lock);
	58
	59	if (vnode->cb_server == server) {
	60	vnode->cb_server = NULL;
	61	afs_kafstimod_del_timer(&vnode->cb_timeout);
	62	spin_lock(&afs_cb_hash_lock);
	63	list_del_init(&vnode->cb_hash_link);
	64	spin_unlock(&afs_cb_hash_lock);
65	release = 1;
66	}
67
68	spin_unlock(&vnode->lock);
69
70	iput(inode);
71	afs_put_server(server);
72
73	spin_lock(&server->cb_lock);
74	}
75	}
76
77	spin_unlock(&server->cb_lock);
78
79	_leave(" = 0");
80	return 0;
81	} /* end SRXAFSCM_InitCallBackState() */
82
83	/*****************************************************************************/
84	/*
85	* allow the fileserver to break callback promises
86	*/
87	int SRXAFSCM_CallBack(struct afs_server *server, size_t count,
88	struct afs_callback callbacks[])
89	{
90	_enter("%p,%u,", server, count);
91
92	for (; count > 0; callbacks++, count--) {
93	struct afs_vnode *vnode = NULL;
94	struct inode *inode = NULL;
95	int valid = 0;
96
97	_debug("- Fid { vl=%08x n=%u u=%u } CB { v=%u x=%u t=%u }",
98	callbacks->fid.vid,
99	callbacks->fid.vnode,
100	callbacks->fid.unique,
101	callbacks->version,
102	callbacks->expiry,
103	callbacks->type
104	);
105
106	/* find the inode for this fid */
107	spin_lock(&afs_cb_hash_lock);
108
109	list_for_each_entry(vnode,
110	&afs_cb_hash(server, &callbacks->fid),
111	cb_hash_link) {
112	if (memcmp(&vnode->fid, &callbacks->fid,
113	sizeof(struct afs_fid)) != 0)
114	continue;
115
116	/* right vnode, but is it same server? */
117	if (vnode->cb_server != server)
118	break; /* no */
119
120	/* try and nail the inode down */
121	inode = igrab(AFS_VNODE_TO_I(vnode));
122	break;
123	}
124
125	spin_unlock(&afs_cb_hash_lock);
126
127	if (inode) {
128	/* we've found the record for this vnode */
129	spin_lock(&vnode->lock);
130	if (vnode->cb_server == server) {
131	/* the callback _is_ on the calling server */
132	vnode->cb_server = NULL;
133	valid = 1;
134
135	afs_kafstimod_del_timer(&vnode->cb_timeout);
136	vnode->flags \|= AFS_VNODE_CHANGED;
137
138	spin_lock(&server->cb_lock);
139	list_del_init(&vnode->cb_link);
140	spin_unlock(&server->cb_lock);
141
142	spin_lock(&afs_cb_hash_lock);
143	list_del_init(&vnode->cb_hash_link);
144	spin_unlock(&afs_cb_hash_lock);
145	}
146	spin_unlock(&vnode->lock);
147
148	if (valid) {
149	invalidate_remote_inode(inode);
150	afs_put_server(server);
151	}
152	iput(inode);
153	}
154	}
155
156	_leave(" = 0");
157	return 0;
158	} /* end SRXAFSCM_CallBack() */
159
160	/*****************************************************************************/
161	/*
162	* allow the fileserver to see if the cache manager is still alive
163	*/
164	int SRXAFSCM_Probe(struct afs_server *server)
165	{
166	_debug("SRXAFSCM_Probe(%p)\n", server);
167	return 0;
168	} /* end SRXAFSCM_Probe() */