Char: n_hdlc, allow RESTARTSYS retval of tty write
[deliverable/linux.git] / fs / afs / callback.c
CommitLineData
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
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;
1da177e4 32
1da177e4
LT
33/*
34 * allow the fileserver to request callback state (re-)initialisation
35 */
08e0e7c8 36void 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 */
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);
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 92out:
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 */
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("");
ec26815a 184}
1da177e4 185
1da177e4
LT
186/*
187 * allow the fileserver to break callback promises
188 */
08e0e7c8
DH
189void afs_break_callbacks(struct afs_server *server, size_t count,
190 struct afs_callback callbacks[])
1da177e4 191{
08e0e7c8 192 _enter("%p,%zu,", server, count);
1da177e4 193
08e0e7c8
DH
194 ASSERT(server != NULL);
195 ASSERTCMP(count, <=, AFSCBMAX);
1da177e4 196
08e0e7c8 197 for (; count > 0; callbacks++, count--) {
1da177e4
LT
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 );
08e0e7c8
DH
206 afs_break_one_callback(server, &callbacks->fid);
207 }
208
209 _leave("");
210 return;
211}
1da177e4 212
08e0e7c8
DH
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;
1da177e4 221
08e0e7c8 222 _enter("%p,%p", server, vnode);
1da177e4 223
08e0e7c8
DH
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);
1da177e4 233
08e0e7c8
DH
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
260a9803
DH
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
08e0e7c8
DH
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);
1da177e4 312 }
08e0e7c8
DH
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#if 0
355/*
356 * update a bunch of callbacks
357 */
358static void afs_callback_updater(struct work_struct *work)
359{
360 struct afs_server *server;
361 struct afs_vnode *vnode, *xvnode;
362 time_t now;
363 long timeout;
364 int ret;
365
366 server = container_of(work, struct afs_server, updater);
367
368 _enter("");
1da177e4 369
08e0e7c8
DH
370 now = get_seconds();
371
372 /* find the first vnode to update */
373 spin_lock(&server->cb_lock);
374 for (;;) {
375 if (RB_EMPTY_ROOT(&server->cb_promises)) {
376 spin_unlock(&server->cb_lock);
377 _leave(" [nothing]");
378 return;
1da177e4 379 }
08e0e7c8
DH
380
381 vnode = rb_entry(rb_first(&server->cb_promises),
382 struct afs_vnode, cb_promise);
383 if (atomic_read(&vnode->usage) > 0)
384 break;
385 rb_erase(&vnode->cb_promise, &server->cb_promises);
386 vnode->cb_promised = false;
387 }
388
389 timeout = vnode->update_at - now;
390 if (timeout > 0) {
391 queue_delayed_work(afs_vnode_update_worker,
392 &afs_vnode_update, timeout * HZ);
393 spin_unlock(&server->cb_lock);
394 _leave(" [nothing]");
395 return;
396 }
397
398 list_del_init(&vnode->update);
399 atomic_inc(&vnode->usage);
400 spin_unlock(&server->cb_lock);
401
402 /* we can now perform the update */
403 _debug("update %s", vnode->vldb.name);
404 vnode->state = AFS_VL_UPDATING;
405 vnode->upd_rej_cnt = 0;
406 vnode->upd_busy_cnt = 0;
407
408 ret = afs_vnode_update_record(vl, &vldb);
409 switch (ret) {
410 case 0:
411 afs_vnode_apply_update(vl, &vldb);
412 vnode->state = AFS_VL_UPDATING;
413 break;
414 case -ENOMEDIUM:
415 vnode->state = AFS_VL_VOLUME_DELETED;
416 break;
417 default:
418 vnode->state = AFS_VL_UNCERTAIN;
419 break;
420 }
421
422 /* and then reschedule */
423 _debug("reschedule");
424 vnode->update_at = get_seconds() + afs_vnode_update_timeout;
425
426 spin_lock(&server->cb_lock);
427
428 if (!list_empty(&server->cb_promises)) {
429 /* next update in 10 minutes, but wait at least 1 second more
430 * than the newest record already queued so that we don't spam
431 * the VL server suddenly with lots of requests
432 */
433 xvnode = list_entry(server->cb_promises.prev,
434 struct afs_vnode, update);
435 if (vnode->update_at <= xvnode->update_at)
436 vnode->update_at = xvnode->update_at + 1;
437 xvnode = list_entry(server->cb_promises.next,
438 struct afs_vnode, update);
439 timeout = xvnode->update_at - now;
440 if (timeout < 0)
441 timeout = 0;
442 } else {
443 timeout = afs_vnode_update_timeout;
1da177e4
LT
444 }
445
08e0e7c8
DH
446 list_add_tail(&vnode->update, &server->cb_promises);
447
448 _debug("timeout %ld", timeout);
449 queue_delayed_work(afs_vnode_update_worker,
450 &afs_vnode_update, timeout * HZ);
451 spin_unlock(&server->cb_lock);
452 afs_put_vnode(vl);
453}
454#endif
455
456/*
457 * initialise the callback update process
458 */
459int __init afs_callback_update_init(void)
460{
461 afs_callback_update_worker =
462 create_singlethread_workqueue("kafs_callbackd");
463 return afs_callback_update_worker ? 0 : -ENOMEM;
ec26815a 464}
1da177e4 465
1da177e4 466/*
08e0e7c8 467 * shut down the callback update process
1da177e4 468 */
fbb3fcba 469void afs_callback_update_kill(void)
1da177e4 470{
08e0e7c8 471 destroy_workqueue(afs_callback_update_worker);
ec26815a 472}
This page took 0.227397 seconds and 5 git commands to generate.