[AFS]: Add security support.
[linux-2.6.git] / 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                 printk("\nUNPROMISE on %p\n", vnode);
48                 rb_erase(&vnode->cb_promise, &server->cb_promises);
49                 vnode->cb_promised = false;
50         }
51
52         spin_unlock(&server->cb_lock);
53         _leave("");
54 }
55
56 /*
57  * handle the data invalidation side of a callback being broken
58  */
59 void afs_broken_callback_work(struct work_struct *work)
60 {
61         struct afs_vnode *vnode =
62                 container_of(work, struct afs_vnode, cb_broken_work);
63
64         _enter("");
65
66         if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
67                 return;
68
69         /* we're only interested in dealing with a broken callback on *this*
70          * vnode and only if no-one else has dealt with it yet */
71         if (!mutex_trylock(&vnode->cb_broken_lock))
72                 return; /* someone else is dealing with it */
73
74         if (test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags)) {
75                 if (S_ISDIR(vnode->vfs_inode.i_mode))
76                         afs_clear_permits(vnode);
77
78                 if (afs_vnode_fetch_status(vnode, NULL, NULL) < 0)
79                         goto out;
80
81                 if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
82                         goto out;
83
84                 /* if the vnode's data version number changed then its contents
85                  * are different */
86                 if (test_and_clear_bit(AFS_VNODE_ZAP_DATA, &vnode->flags)) {
87                         _debug("zap data");
88                         invalidate_remote_inode(&vnode->vfs_inode);
89                 }
90         }
91
92 out:
93         mutex_unlock(&vnode->cb_broken_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  */
108 static 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  */
138 static 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) */
167 not_available:
168         _debug("not avail");
169         spin_unlock(&server->fs_lock);
170         _leave("");
171         return;
172
173 found:
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  */
189 void 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  */
217 static 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  * give up the callback registered for a vnode on the file server when the
256  * inode is being cleared
257  */
258 void afs_give_up_callback(struct afs_vnode *vnode)
259 {
260         struct afs_server *server = vnode->server;
261
262         DECLARE_WAITQUEUE(myself, current);
263
264         _enter("%d", vnode->cb_promised);
265
266         _debug("GIVE UP INODE %p", &vnode->vfs_inode);
267
268         if (!vnode->cb_promised) {
269                 _leave(" [not promised]");
270                 return;
271         }
272
273         ASSERT(server != NULL);
274
275         spin_lock(&server->cb_lock);
276         if (vnode->cb_promised && afs_breakring_space(server) == 0) {
277                 add_wait_queue(&server->cb_break_waitq, &myself);
278                 for (;;) {
279                         set_current_state(TASK_UNINTERRUPTIBLE);
280                         if (!vnode->cb_promised ||
281                             afs_breakring_space(server) != 0)
282                                 break;
283                         spin_unlock(&server->cb_lock);
284                         schedule();
285                         spin_lock(&server->cb_lock);
286                 }
287                 remove_wait_queue(&server->cb_break_waitq, &myself);
288                 __set_current_state(TASK_RUNNING);
289         }
290
291         /* of course, it's always possible for the server to break this vnode's
292          * callback first... */
293         if (vnode->cb_promised)
294                 afs_do_give_up_callback(server, vnode);
295
296         spin_unlock(&server->cb_lock);
297         _leave("");
298 }
299
300 /*
301  * dispatch a deferred give up callbacks operation
302  */
303 void afs_dispatch_give_up_callbacks(struct work_struct *work)
304 {
305         struct afs_server *server =
306                 container_of(work, struct afs_server, cb_break_work.work);
307
308         _enter("");
309
310         /* tell the fileserver to discard the callback promises it has
311          * - in the event of ENOMEM or some other error, we just forget that we
312          *   had callbacks entirely, and the server will call us later to break
313          *   them
314          */
315         afs_fs_give_up_callbacks(server, &afs_async_call);
316 }
317
318 /*
319  * flush the outstanding callback breaks on a server
320  */
321 void afs_flush_callback_breaks(struct afs_server *server)
322 {
323         cancel_delayed_work(&server->cb_break_work);
324         queue_delayed_work(afs_callback_update_worker,
325                            &server->cb_break_work, 0);
326 }
327
328 #if 0
329 /*
330  * update a bunch of callbacks
331  */
332 static void afs_callback_updater(struct work_struct *work)
333 {
334         struct afs_server *server;
335         struct afs_vnode *vnode, *xvnode;
336         time_t now;
337         long timeout;
338         int ret;
339
340         server = container_of(work, struct afs_server, updater);
341
342         _enter("");
343
344         now = get_seconds();
345
346         /* find the first vnode to update */
347         spin_lock(&server->cb_lock);
348         for (;;) {
349                 if (RB_EMPTY_ROOT(&server->cb_promises)) {
350                         spin_unlock(&server->cb_lock);
351                         _leave(" [nothing]");
352                         return;
353                 }
354
355                 vnode = rb_entry(rb_first(&server->cb_promises),
356                                  struct afs_vnode, cb_promise);
357                 if (atomic_read(&vnode->usage) > 0)
358                         break;
359                 rb_erase(&vnode->cb_promise, &server->cb_promises);
360                 vnode->cb_promised = false;
361         }
362
363         timeout = vnode->update_at - now;
364         if (timeout > 0) {
365                 queue_delayed_work(afs_vnode_update_worker,
366                                    &afs_vnode_update, timeout * HZ);
367                 spin_unlock(&server->cb_lock);
368                 _leave(" [nothing]");
369                 return;
370         }
371
372         list_del_init(&vnode->update);
373         atomic_inc(&vnode->usage);
374         spin_unlock(&server->cb_lock);
375
376         /* we can now perform the update */
377         _debug("update %s", vnode->vldb.name);
378         vnode->state = AFS_VL_UPDATING;
379         vnode->upd_rej_cnt = 0;
380         vnode->upd_busy_cnt = 0;
381
382         ret = afs_vnode_update_record(vl, &vldb);
383         switch (ret) {
384         case 0:
385                 afs_vnode_apply_update(vl, &vldb);
386                 vnode->state = AFS_VL_UPDATING;
387                 break;
388         case -ENOMEDIUM:
389                 vnode->state = AFS_VL_VOLUME_DELETED;
390                 break;
391         default:
392                 vnode->state = AFS_VL_UNCERTAIN;
393                 break;
394         }
395
396         /* and then reschedule */
397         _debug("reschedule");
398         vnode->update_at = get_seconds() + afs_vnode_update_timeout;
399
400         spin_lock(&server->cb_lock);
401
402         if (!list_empty(&server->cb_promises)) {
403                 /* next update in 10 minutes, but wait at least 1 second more
404                  * than the newest record already queued so that we don't spam
405                  * the VL server suddenly with lots of requests
406                  */
407                 xvnode = list_entry(server->cb_promises.prev,
408                                     struct afs_vnode, update);
409                 if (vnode->update_at <= xvnode->update_at)
410                         vnode->update_at = xvnode->update_at + 1;
411                 xvnode = list_entry(server->cb_promises.next,
412                                     struct afs_vnode, update);
413                 timeout = xvnode->update_at - now;
414                 if (timeout < 0)
415                         timeout = 0;
416         } else {
417                 timeout = afs_vnode_update_timeout;
418         }
419
420         list_add_tail(&vnode->update, &server->cb_promises);
421
422         _debug("timeout %ld", timeout);
423         queue_delayed_work(afs_vnode_update_worker,
424                            &afs_vnode_update, timeout * HZ);
425         spin_unlock(&server->cb_lock);
426         afs_put_vnode(vl);
427 }
428 #endif
429
430 /*
431  * initialise the callback update process
432  */
433 int __init afs_callback_update_init(void)
434 {
435         afs_callback_update_worker =
436                 create_singlethread_workqueue("kafs_callbackd");
437         return afs_callback_update_worker ? 0 : -ENOMEM;
438 }
439
440 /*
441  * shut down the callback update process
442  */
443 void __exit afs_callback_update_kill(void)
444 {
445         destroy_workqueue(afs_callback_update_worker);
446 }