1/*
2 * Copyright (c) 2002, 2007 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 <dwmw2@cambridge.redhat.com>
12 *          David Howells <dhowells@redhat.com>
13 *
14 */
15
16#include <linux/kernel.h>
17#include <linux/module.h>
18#include <linux/init.h>
19#include <linux/circ_buf.h>
20#include <linux/sched.h>
21#include "internal.h"
22
23unsigned afs_vnode_update_timeout = 10;
24
25#define afs_breakring_space(server) \
26	CIRC_SPACE((server)->cb_break_head, (server)->cb_break_tail,	\
27		   ARRAY_SIZE((server)->cb_break))
28
29//static void afs_callback_updater(struct work_struct *);
30
31static struct workqueue_struct *afs_callback_update_worker;
32
33/*
34 * allow the fileserver to request callback state (re-)initialisation
35 */
36void afs_init_callback_state(struct afs_server *server)
37{
38	struct afs_vnode *vnode;
39
40	_enter("{%p}", server);
41
42	spin_lock(&server->cb_lock);
43
44	/* kill all the promises on record from this server */
45	while (!RB_EMPTY_ROOT(&server->cb_promises)) {
46		vnode = rb_entry(server->cb_promises.rb_node,
47				 struct afs_vnode, cb_promise);
48		_debug("UNPROMISE { vid=%x:%u uq=%u}",
49		       vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
50		rb_erase(&vnode->cb_promise, &server->cb_promises);
51		vnode->cb_promised = false;
52	}
53
54	spin_unlock(&server->cb_lock);
55	_leave("");
56}
57
58/*
59 * handle the data invalidation side of a callback being broken
60 */
61void afs_broken_callback_work(struct work_struct *work)
62{
63	struct afs_vnode *vnode =
64		container_of(work, struct afs_vnode, cb_broken_work);
65
66	_enter("");
67
68	if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
69		return;
70
71	/* we're only interested in dealing with a broken callback on *this*
72	 * vnode and only if no-one else has dealt with it yet */
73	if (!mutex_trylock(&vnode->validate_lock))
74		return; /* someone else is dealing with it */
75
76	if (test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags)) {
77		if (S_ISDIR(vnode->vfs_inode.i_mode))
78			afs_clear_permits(vnode);
79
80		if (afs_vnode_fetch_status(vnode, NULL, NULL) < 0)
81			goto out;
82
83		if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
84			goto out;
85
86		/* if the vnode's data version number changed then its contents
87		 * are different */
88		if (test_and_clear_bit(AFS_VNODE_ZAP_DATA, &vnode->flags))
89			afs_zap_data(vnode);
90	}
91
92out:
93	mutex_unlock(&vnode->validate_lock);
94
95	/* avoid the potential race whereby the mutex_trylock() in this
96	 * function happens again between the clear_bit() and the
97	 * mutex_unlock() */
98	if (test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags)) {
99		_debug("requeue");
100		queue_work(afs_callback_update_worker, &vnode->cb_broken_work);
101	}
102	_leave("");
103}
104
105/*
106 * actually break a callback
107 */
108static void afs_break_callback(struct afs_server *server,
109			       struct afs_vnode *vnode)
110{
111	_enter("");
112
113	set_bit(AFS_VNODE_CB_BROKEN, &vnode->flags);
114
115	if (vnode->cb_promised) {
116		spin_lock(&vnode->lock);
117
118		_debug("break callback");
119
120		spin_lock(&server->cb_lock);
121		if (vnode->cb_promised) {
122			rb_erase(&vnode->cb_promise, &server->cb_promises);
123			vnode->cb_promised = false;
124		}
125		spin_unlock(&server->cb_lock);
126
127		queue_work(afs_callback_update_worker, &vnode->cb_broken_work);
128		spin_unlock(&vnode->lock);
129	}
130}
131
132/*
133 * allow the fileserver to explicitly break one callback
134 * - happens when
135 *   - the backing file is changed
136 *   - a lock is released
137 */
138static void afs_break_one_callback(struct afs_server *server,
139				   struct afs_fid *fid)
140{
141	struct afs_vnode *vnode;
142	struct rb_node *p;
143
144	_debug("find");
145	spin_lock(&server->fs_lock);
146	p = server->fs_vnodes.rb_node;
147	while (p) {
148		vnode = rb_entry(p, struct afs_vnode, server_rb);
149		if (fid->vid < vnode->fid.vid)
150			p = p->rb_left;
151		else if (fid->vid > vnode->fid.vid)
152			p = p->rb_right;
153		else if (fid->vnode < vnode->fid.vnode)
154			p = p->rb_left;
155		else if (fid->vnode > vnode->fid.vnode)
156			p = p->rb_right;
157		else if (fid->unique < vnode->fid.unique)
158			p = p->rb_left;
159		else if (fid->unique > vnode->fid.unique)
160			p = p->rb_right;
161		else
162			goto found;
163	}
164
165	/* not found so we just ignore it (it may have moved to another
166	 * server) */
167not_available:
168	_debug("not avail");
169	spin_unlock(&server->fs_lock);
170	_leave("");
171	return;
172
173found:
174	_debug("found");
175	ASSERTCMP(server, ==, vnode->server);
176
177	if (!igrab(AFS_VNODE_TO_I(vnode)))
178		goto not_available;
179	spin_unlock(&server->fs_lock);
180
181	afs_break_callback(server, vnode);
182	iput(&vnode->vfs_inode);
183	_leave("");
184}
185
186/*
187 * allow the fileserver to break callback promises
188 */
189void afs_break_callbacks(struct afs_server *server, size_t count,
190			 struct afs_callback callbacks[])
191{
192	_enter("%p,%zu,", server, count);
193
194	ASSERT(server != NULL);
195	ASSERTCMP(count, <=, AFSCBMAX);
196
197	for (; count > 0; callbacks++, count--) {
198		_debug("- Fid { vl=%08x n=%u u=%u }  CB { v=%u x=%u t=%u }",
199		       callbacks->fid.vid,
200		       callbacks->fid.vnode,
201		       callbacks->fid.unique,
202		       callbacks->version,
203		       callbacks->expiry,
204		       callbacks->type
205		       );
206		afs_break_one_callback(server, &callbacks->fid);
207	}
208
209	_leave("");
210	return;
211}
212
213/*
214 * record the callback for breaking
215 * - the caller must hold server->cb_lock
216 */
217static void afs_do_give_up_callback(struct afs_server *server,
218				    struct afs_vnode *vnode)
219{
220	struct afs_callback *cb;
221
222	_enter("%p,%p", server, vnode);
223
224	cb = &server->cb_break[server->cb_break_head];
225	cb->fid		= vnode->fid;
226	cb->version	= vnode->cb_version;
227	cb->expiry	= vnode->cb_expiry;
228	cb->type	= vnode->cb_type;
229	smp_wmb();
230	server->cb_break_head =
231		(server->cb_break_head + 1) &
232		(ARRAY_SIZE(server->cb_break) - 1);
233
234	/* defer the breaking of callbacks to try and collect as many as
235	 * possible to ship in one operation */
236	switch (atomic_inc_return(&server->cb_break_n)) {
237	case 1 ... AFSCBMAX - 1:
238		queue_delayed_work(afs_callback_update_worker,
239				   &server->cb_break_work, HZ * 2);
240		break;
241	case AFSCBMAX:
242		afs_flush_callback_breaks(server);
243		break;
244	default:
245		break;
246	}
247
248	ASSERT(server->cb_promises.rb_node != NULL);
249	rb_erase(&vnode->cb_promise, &server->cb_promises);
250	vnode->cb_promised = false;
251	_leave("");
252}
253
254/*
255 * discard the callback on a deleted item
256 */
257void afs_discard_callback_on_delete(struct afs_vnode *vnode)
258{
259	struct afs_server *server = vnode->server;
260
261	_enter("%d", vnode->cb_promised);
262
263	if (!vnode->cb_promised) {
264		_leave(" [not promised]");
265		return;
266	}
267
268	ASSERT(server != NULL);
269
270	spin_lock(&server->cb_lock);
271	if (vnode->cb_promised) {
272		ASSERT(server->cb_promises.rb_node != NULL);
273		rb_erase(&vnode->cb_promise, &server->cb_promises);
274		vnode->cb_promised = false;
275	}
276	spin_unlock(&server->cb_lock);
277	_leave("");
278}
279
280/*
281 * give up the callback registered for a vnode on the file server when the
282 * inode is being cleared
283 */
284void afs_give_up_callback(struct afs_vnode *vnode)
285{
286	struct afs_server *server = vnode->server;
287
288	DECLARE_WAITQUEUE(myself, current);
289
290	_enter("%d", vnode->cb_promised);
291
292	_debug("GIVE UP INODE %p", &vnode->vfs_inode);
293
294	if (!vnode->cb_promised) {
295		_leave(" [not promised]");
296		return;
297	}
298
299	ASSERT(server != NULL);
300
301	spin_lock(&server->cb_lock);
302	if (vnode->cb_promised && afs_breakring_space(server) == 0) {
303		add_wait_queue(&server->cb_break_waitq, &myself);
304		for (;;) {
305			set_current_state(TASK_UNINTERRUPTIBLE);
306			if (!vnode->cb_promised ||
307			    afs_breakring_space(server) != 0)
308				break;
309			spin_unlock(&server->cb_lock);
310			schedule();
311			spin_lock(&server->cb_lock);
312		}
313		remove_wait_queue(&server->cb_break_waitq, &myself);
314		__set_current_state(TASK_RUNNING);
315	}
316
317	/* of course, it's always possible for the server to break this vnode's
318	 * callback first... */
319	if (vnode->cb_promised)
320		afs_do_give_up_callback(server, vnode);
321
322	spin_unlock(&server->cb_lock);
323	_leave("");
324}
325
326/*
327 * dispatch a deferred give up callbacks operation
328 */
329void afs_dispatch_give_up_callbacks(struct work_struct *work)
330{
331	struct afs_server *server =
332		container_of(work, struct afs_server, cb_break_work.work);
333
334	_enter("");
335
336	/* tell the fileserver to discard the callback promises it has
337	 * - in the event of ENOMEM or some other error, we just forget that we
338	 *   had callbacks entirely, and the server will call us later to break
339	 *   them
340	 */
341	afs_fs_give_up_callbacks(server, &afs_async_call);
342}
343
344/*
345 * flush the outstanding callback breaks on a server
346 */
347void afs_flush_callback_breaks(struct afs_server *server)
348{
349	cancel_delayed_work(&server->cb_break_work);
350	queue_delayed_work(afs_callback_update_worker,
351			   &server->cb_break_work, 0);
352}
353
354
355/*
356 * initialise the callback update process
357 */
358int __init afs_callback_update_init(void)
359{
360	afs_callback_update_worker =
361		create_singlethread_workqueue("kafs_callbackd");
362	return afs_callback_update_worker ? 0 : -ENOMEM;
363}
364
365/*
366 * shut down the callback update process
367 */
368void afs_callback_update_kill(void)
369{
370	destroy_workqueue(afs_callback_update_worker);
371}
372