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