Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/avi/kvm
[linux-2.6] / fs / afs / callback.c
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 "internal.h"
21
22 unsigned afs_vnode_update_timeout = 10;
23
24 #define afs_breakring_space(server) \
25         CIRC_SPACE((server)->cb_break_head, (server)->cb_break_tail,    \
26                    ARRAY_SIZE((server)->cb_break))
27
28 //static void afs_callback_updater(struct work_struct *);
29
30 static struct workqueue_struct *afs_callback_update_worker;
31
32 /*
33  * allow the fileserver to request callback state (re-)initialisation
34  */
35 void afs_init_callback_state(struct afs_server *server)
36 {
37         struct afs_vnode *vnode;
38
39         _enter("{%p}", server);
40
41         spin_lock(&server->cb_lock);
42
43         /* kill all the promises on record from this server */
44         while (!RB_EMPTY_ROOT(&server->cb_promises)) {
45                 vnode = rb_entry(server->cb_promises.rb_node,
46                                  struct afs_vnode, cb_promise);
47                 _debug("UNPROMISE { vid=%x vn=%u uq=%u}",
48                        vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
49                 rb_erase(&vnode->cb_promise, &server->cb_promises);
50                 vnode->cb_promised = false;
51         }
52
53         spin_unlock(&server->cb_lock);
54         _leave("");
55 }
56
57 /*
58  * handle the data invalidation side of a callback being broken
59  */
60 void afs_broken_callback_work(struct work_struct *work)
61 {
62         struct afs_vnode *vnode =
63                 container_of(work, struct afs_vnode, cb_broken_work);
64
65         _enter("");
66
67         if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
68                 return;
69
70         /* we're only interested in dealing with a broken callback on *this*
71          * vnode and only if no-one else has dealt with it yet */
72         if (!mutex_trylock(&vnode->validate_lock))
73                 return; /* someone else is dealing with it */
74
75         if (test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags)) {
76                 if (S_ISDIR(vnode->vfs_inode.i_mode))
77                         afs_clear_permits(vnode);
78
79                 if (afs_vnode_fetch_status(vnode, NULL, NULL) < 0)
80                         goto out;
81
82                 if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
83                         goto out;
84
85                 /* if the vnode's data version number changed then its contents
86                  * are different */
87                 if (test_and_clear_bit(AFS_VNODE_ZAP_DATA, &vnode->flags)) {
88                         _debug("zap data {%x:%u}",
89                                vnode->fid.vid, vnode->fid.vnode);
90                         invalidate_remote_inode(&vnode->vfs_inode);
91                 }
92         }
93
94 out:
95         mutex_unlock(&vnode->validate_lock);
96
97         /* avoid the potential race whereby the mutex_trylock() in this
98          * function happens again between the clear_bit() and the
99          * mutex_unlock() */
100         if (test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags)) {
101                 _debug("requeue");
102                 queue_work(afs_callback_update_worker, &vnode->cb_broken_work);
103         }
104         _leave("");
105 }
106
107 /*
108  * actually break a callback
109  */
110 static void afs_break_callback(struct afs_server *server,
111                                struct afs_vnode *vnode)
112 {
113         _enter("");
114
115         set_bit(AFS_VNODE_CB_BROKEN, &vnode->flags);
116
117         if (vnode->cb_promised) {
118                 spin_lock(&vnode->lock);
119
120                 _debug("break callback");
121
122                 spin_lock(&server->cb_lock);
123                 if (vnode->cb_promised) {
124                         rb_erase(&vnode->cb_promise, &server->cb_promises);
125                         vnode->cb_promised = false;
126                 }
127                 spin_unlock(&server->cb_lock);
128
129                 queue_work(afs_callback_update_worker, &vnode->cb_broken_work);
130                 spin_unlock(&vnode->lock);
131         }
132 }
133
134 /*
135  * allow the fileserver to explicitly break one callback
136  * - happens when
137  *   - the backing file is changed
138  *   - a lock is released
139  */
140 static void afs_break_one_callback(struct afs_server *server,
141                                    struct afs_fid *fid)
142 {
143         struct afs_vnode *vnode;
144         struct rb_node *p;
145
146         _debug("find");
147         spin_lock(&server->fs_lock);
148         p = server->fs_vnodes.rb_node;
149         while (p) {
150                 vnode = rb_entry(p, struct afs_vnode, server_rb);
151                 if (fid->vid < vnode->fid.vid)
152                         p = p->rb_left;
153                 else if (fid->vid > vnode->fid.vid)
154                         p = p->rb_right;
155                 else if (fid->vnode < vnode->fid.vnode)
156                         p = p->rb_left;
157                 else if (fid->vnode > vnode->fid.vnode)
158                         p = p->rb_right;
159                 else if (fid->unique < vnode->fid.unique)
160                         p = p->rb_left;
161                 else if (fid->unique > vnode->fid.unique)
162                         p = p->rb_right;
163                 else
164                         goto found;
165         }
166
167         /* not found so we just ignore it (it may have moved to another
168          * server) */
169 not_available:
170         _debug("not avail");
171         spin_unlock(&server->fs_lock);
172         _leave("");
173         return;
174
175 found:
176         _debug("found");
177         ASSERTCMP(server, ==, vnode->server);
178
179         if (!igrab(AFS_VNODE_TO_I(vnode)))
180                 goto not_available;
181         spin_unlock(&server->fs_lock);
182
183         afs_break_callback(server, vnode);
184         iput(&vnode->vfs_inode);
185         _leave("");
186 }
187
188 /*
189  * allow the fileserver to break callback promises
190  */
191 void afs_break_callbacks(struct afs_server *server, size_t count,
192                          struct afs_callback callbacks[])
193 {
194         _enter("%p,%zu,", server, count);
195
196         ASSERT(server != NULL);
197         ASSERTCMP(count, <=, AFSCBMAX);
198
199         for (; count > 0; callbacks++, count--) {
200                 _debug("- Fid { vl=%08x n=%u u=%u }  CB { v=%u x=%u t=%u }",
201                        callbacks->fid.vid,
202                        callbacks->fid.vnode,
203                        callbacks->fid.unique,
204                        callbacks->version,
205                        callbacks->expiry,
206                        callbacks->type
207                        );
208                 afs_break_one_callback(server, &callbacks->fid);
209         }
210
211         _leave("");
212         return;
213 }
214
215 /*
216  * record the callback for breaking
217  * - the caller must hold server->cb_lock
218  */
219 static void afs_do_give_up_callback(struct afs_server *server,
220                                     struct afs_vnode *vnode)
221 {
222         struct afs_callback *cb;
223
224         _enter("%p,%p", server, vnode);
225
226         cb = &server->cb_break[server->cb_break_head];
227         cb->fid         = vnode->fid;
228         cb->version     = vnode->cb_version;
229         cb->expiry      = vnode->cb_expiry;
230         cb->type        = vnode->cb_type;
231         smp_wmb();
232         server->cb_break_head =
233                 (server->cb_break_head + 1) &
234                 (ARRAY_SIZE(server->cb_break) - 1);
235
236         /* defer the breaking of callbacks to try and collect as many as
237          * possible to ship in one operation */
238         switch (atomic_inc_return(&server->cb_break_n)) {
239         case 1 ... AFSCBMAX - 1:
240                 queue_delayed_work(afs_callback_update_worker,
241                                    &server->cb_break_work, HZ * 2);
242                 break;
243         case AFSCBMAX:
244                 afs_flush_callback_breaks(server);
245                 break;
246         default:
247                 break;
248         }
249
250         ASSERT(server->cb_promises.rb_node != NULL);
251         rb_erase(&vnode->cb_promise, &server->cb_promises);
252         vnode->cb_promised = false;
253         _leave("");
254 }
255
256 /*
257  * discard the callback on a deleted item
258  */
259 void afs_discard_callback_on_delete(struct afs_vnode *vnode)
260 {
261         struct afs_server *server = vnode->server;
262
263         _enter("%d", vnode->cb_promised);
264
265         if (!vnode->cb_promised) {
266                 _leave(" [not promised]");
267                 return;
268         }
269
270         ASSERT(server != NULL);
271
272         spin_lock(&server->cb_lock);
273         if (vnode->cb_promised) {
274                 ASSERT(server->cb_promises.rb_node != NULL);
275                 rb_erase(&vnode->cb_promise, &server->cb_promises);
276                 vnode->cb_promised = false;
277         }
278         spin_unlock(&server->cb_lock);
279         _leave("");
280 }
281
282 /*
283  * give up the callback registered for a vnode on the file server when the
284  * inode is being cleared
285  */
286 void afs_give_up_callback(struct afs_vnode *vnode)
287 {
288         struct afs_server *server = vnode->server;
289
290         DECLARE_WAITQUEUE(myself, current);
291
292         _enter("%d", vnode->cb_promised);
293
294         _debug("GIVE UP INODE %p", &vnode->vfs_inode);
295
296         if (!vnode->cb_promised) {
297                 _leave(" [not promised]");
298                 return;
299         }
300
301         ASSERT(server != NULL);
302
303         spin_lock(&server->cb_lock);
304         if (vnode->cb_promised && afs_breakring_space(server) == 0) {
305                 add_wait_queue(&server->cb_break_waitq, &myself);
306                 for (;;) {
307                         set_current_state(TASK_UNINTERRUPTIBLE);
308                         if (!vnode->cb_promised ||
309                             afs_breakring_space(server) != 0)
310                                 break;
311                         spin_unlock(&server->cb_lock);
312                         schedule();
313                         spin_lock(&server->cb_lock);
314                 }
315                 remove_wait_queue(&server->cb_break_waitq, &myself);
316                 __set_current_state(TASK_RUNNING);
317         }
318
319         /* of course, it's always possible for the server to break this vnode's
320          * callback first... */
321         if (vnode->cb_promised)
322                 afs_do_give_up_callback(server, vnode);
323
324         spin_unlock(&server->cb_lock);
325         _leave("");
326 }
327
328 /*
329  * dispatch a deferred give up callbacks operation
330  */
331 void afs_dispatch_give_up_callbacks(struct work_struct *work)
332 {
333         struct afs_server *server =
334                 container_of(work, struct afs_server, cb_break_work.work);
335
336         _enter("");
337
338         /* tell the fileserver to discard the callback promises it has
339          * - in the event of ENOMEM or some other error, we just forget that we
340          *   had callbacks entirely, and the server will call us later to break
341          *   them
342          */
343         afs_fs_give_up_callbacks(server, &afs_async_call);
344 }
345
346 /*
347  * flush the outstanding callback breaks on a server
348  */
349 void afs_flush_callback_breaks(struct afs_server *server)
350 {
351         cancel_delayed_work(&server->cb_break_work);
352         queue_delayed_work(afs_callback_update_worker,
353                            &server->cb_break_work, 0);
354 }
355
356 #if 0
357 /*
358  * update a bunch of callbacks
359  */
360 static void afs_callback_updater(struct work_struct *work)
361 {
362         struct afs_server *server;
363         struct afs_vnode *vnode, *xvnode;
364         time_t now;
365         long timeout;
366         int ret;
367
368         server = container_of(work, struct afs_server, updater);
369
370         _enter("");
371
372         now = get_seconds();
373
374         /* find the first vnode to update */
375         spin_lock(&server->cb_lock);
376         for (;;) {
377                 if (RB_EMPTY_ROOT(&server->cb_promises)) {
378                         spin_unlock(&server->cb_lock);
379                         _leave(" [nothing]");
380                         return;
381                 }
382
383                 vnode = rb_entry(rb_first(&server->cb_promises),
384                                  struct afs_vnode, cb_promise);
385                 if (atomic_read(&vnode->usage) > 0)
386                         break;
387                 rb_erase(&vnode->cb_promise, &server->cb_promises);
388                 vnode->cb_promised = false;
389         }
390
391         timeout = vnode->update_at - now;
392         if (timeout > 0) {
393                 queue_delayed_work(afs_vnode_update_worker,
394                                    &afs_vnode_update, timeout * HZ);
395                 spin_unlock(&server->cb_lock);
396                 _leave(" [nothing]");
397                 return;
398         }
399
400         list_del_init(&vnode->update);
401         atomic_inc(&vnode->usage);
402         spin_unlock(&server->cb_lock);
403
404         /* we can now perform the update */
405         _debug("update %s", vnode->vldb.name);
406         vnode->state = AFS_VL_UPDATING;
407         vnode->upd_rej_cnt = 0;
408         vnode->upd_busy_cnt = 0;
409
410         ret = afs_vnode_update_record(vl, &vldb);
411         switch (ret) {
412         case 0:
413                 afs_vnode_apply_update(vl, &vldb);
414                 vnode->state = AFS_VL_UPDATING;
415                 break;
416         case -ENOMEDIUM:
417                 vnode->state = AFS_VL_VOLUME_DELETED;
418                 break;
419         default:
420                 vnode->state = AFS_VL_UNCERTAIN;
421                 break;
422         }
423
424         /* and then reschedule */
425         _debug("reschedule");
426         vnode->update_at = get_seconds() + afs_vnode_update_timeout;
427
428         spin_lock(&server->cb_lock);
429
430         if (!list_empty(&server->cb_promises)) {
431                 /* next update in 10 minutes, but wait at least 1 second more
432                  * than the newest record already queued so that we don't spam
433                  * the VL server suddenly with lots of requests
434                  */
435                 xvnode = list_entry(server->cb_promises.prev,
436                                     struct afs_vnode, update);
437                 if (vnode->update_at <= xvnode->update_at)
438                         vnode->update_at = xvnode->update_at + 1;
439                 xvnode = list_entry(server->cb_promises.next,
440                                     struct afs_vnode, update);
441                 timeout = xvnode->update_at - now;
442                 if (timeout < 0)
443                         timeout = 0;
444         } else {
445                 timeout = afs_vnode_update_timeout;
446         }
447
448         list_add_tail(&vnode->update, &server->cb_promises);
449
450         _debug("timeout %ld", timeout);
451         queue_delayed_work(afs_vnode_update_worker,
452                            &afs_vnode_update, timeout * HZ);
453         spin_unlock(&server->cb_lock);
454         afs_put_vnode(vl);
455 }
456 #endif
457
458 /*
459  * initialise the callback update process
460  */
461 int __init afs_callback_update_init(void)
462 {
463         afs_callback_update_worker =
464                 create_singlethread_workqueue("kafs_callbackd");
465         return afs_callback_update_worker ? 0 : -ENOMEM;
466 }
467
468 /*
469  * shut down the callback update process
470  */
471 void afs_callback_update_kill(void)
472 {
473         destroy_workqueue(afs_callback_update_worker);
474 }