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