| /* |
| * Copyright (c) 2002, 2007 Red Hat, Inc. All rights reserved. |
| * |
| * This software may be freely redistributed under the terms of the |
| * GNU General Public License. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| * |
| * Authors: David Woodhouse <dwmw2@infradead.org> |
| * David Howells <dhowells@redhat.com> |
| * |
| */ |
| |
| #include <linux/kernel.h> |
| #include <linux/module.h> |
| #include <linux/init.h> |
| #include <linux/circ_buf.h> |
| #include <linux/sched.h> |
| #include "internal.h" |
| |
| /* |
| * Create volume and callback interests on a server. |
| */ |
| static struct afs_cb_interest *afs_create_interest(struct afs_server *server, |
| struct afs_vnode *vnode) |
| { |
| struct afs_vol_interest *new_vi, *vi; |
| struct afs_cb_interest *new; |
| struct hlist_node **pp; |
| |
| new_vi = kzalloc(sizeof(struct afs_vol_interest), GFP_KERNEL); |
| if (!new_vi) |
| return NULL; |
| |
| new = kzalloc(sizeof(struct afs_cb_interest), GFP_KERNEL); |
| if (!new) { |
| kfree(new_vi); |
| return NULL; |
| } |
| |
| new_vi->usage = 1; |
| new_vi->vid = vnode->volume->vid; |
| INIT_HLIST_NODE(&new_vi->srv_link); |
| INIT_HLIST_HEAD(&new_vi->cb_interests); |
| |
| refcount_set(&new->usage, 1); |
| new->sb = vnode->vfs_inode.i_sb; |
| new->vid = vnode->volume->vid; |
| new->server = afs_get_server(server); |
| INIT_HLIST_NODE(&new->cb_vlink); |
| |
| write_lock(&server->cb_break_lock); |
| |
| for (pp = &server->cb_volumes.first; *pp; pp = &(*pp)->next) { |
| vi = hlist_entry(*pp, struct afs_vol_interest, srv_link); |
| if (vi->vid < new_vi->vid) |
| continue; |
| if (vi->vid > new_vi->vid) |
| break; |
| vi->usage++; |
| goto found_vi; |
| } |
| |
| new_vi->srv_link.pprev = pp; |
| new_vi->srv_link.next = *pp; |
| if (*pp) |
| (*pp)->pprev = &new_vi->srv_link.next; |
| *pp = &new_vi->srv_link; |
| vi = new_vi; |
| new_vi = NULL; |
| found_vi: |
| |
| new->vol_interest = vi; |
| hlist_add_head(&new->cb_vlink, &vi->cb_interests); |
| |
| write_unlock(&server->cb_break_lock); |
| kfree(new_vi); |
| return new; |
| } |
| |
| /* |
| * Set up an interest-in-callbacks record for a volume on a server and |
| * register it with the server. |
| * - Called with vnode->io_lock held. |
| */ |
| int afs_register_server_cb_interest(struct afs_vnode *vnode, |
| struct afs_server_list *slist, |
| unsigned int index) |
| { |
| struct afs_server_entry *entry = &slist->servers[index]; |
| struct afs_cb_interest *cbi, *vcbi, *new, *old; |
| struct afs_server *server = entry->server; |
| |
| again: |
| if (vnode->cb_interest && |
| likely(vnode->cb_interest == entry->cb_interest)) |
| return 0; |
| |
| read_lock(&slist->lock); |
| cbi = afs_get_cb_interest(entry->cb_interest); |
| read_unlock(&slist->lock); |
| |
| vcbi = vnode->cb_interest; |
| if (vcbi) { |
| if (vcbi == cbi) { |
| afs_put_cb_interest(afs_v2net(vnode), cbi); |
| return 0; |
| } |
| |
| /* Use a new interest in the server list for the same server |
| * rather than an old one that's still attached to a vnode. |
| */ |
| if (cbi && vcbi->server == cbi->server) { |
| write_seqlock(&vnode->cb_lock); |
| old = vnode->cb_interest; |
| vnode->cb_interest = cbi; |
| write_sequnlock(&vnode->cb_lock); |
| afs_put_cb_interest(afs_v2net(vnode), old); |
| return 0; |
| } |
| |
| /* Re-use the one attached to the vnode. */ |
| if (!cbi && vcbi->server == server) { |
| write_lock(&slist->lock); |
| if (entry->cb_interest) { |
| write_unlock(&slist->lock); |
| afs_put_cb_interest(afs_v2net(vnode), cbi); |
| goto again; |
| } |
| |
| entry->cb_interest = cbi; |
| write_unlock(&slist->lock); |
| return 0; |
| } |
| } |
| |
| if (!cbi) { |
| new = afs_create_interest(server, vnode); |
| if (!new) |
| return -ENOMEM; |
| |
| write_lock(&slist->lock); |
| if (!entry->cb_interest) { |
| entry->cb_interest = afs_get_cb_interest(new); |
| cbi = new; |
| new = NULL; |
| } else { |
| cbi = afs_get_cb_interest(entry->cb_interest); |
| } |
| write_unlock(&slist->lock); |
| afs_put_cb_interest(afs_v2net(vnode), new); |
| } |
| |
| ASSERT(cbi); |
| |
| /* Change the server the vnode is using. This entails scrubbing any |
| * interest the vnode had in the previous server it was using. |
| */ |
| write_seqlock(&vnode->cb_lock); |
| |
| old = vnode->cb_interest; |
| vnode->cb_interest = cbi; |
| vnode->cb_s_break = cbi->server->cb_s_break; |
| vnode->cb_v_break = vnode->volume->cb_v_break; |
| clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags); |
| |
| write_sequnlock(&vnode->cb_lock); |
| afs_put_cb_interest(afs_v2net(vnode), old); |
| return 0; |
| } |
| |
| /* |
| * Remove an interest on a server. |
| */ |
| void afs_put_cb_interest(struct afs_net *net, struct afs_cb_interest *cbi) |
| { |
| struct afs_vol_interest *vi; |
| |
| if (cbi && refcount_dec_and_test(&cbi->usage)) { |
| if (!hlist_unhashed(&cbi->cb_vlink)) { |
| write_lock(&cbi->server->cb_break_lock); |
| |
| hlist_del_init(&cbi->cb_vlink); |
| vi = cbi->vol_interest; |
| cbi->vol_interest = NULL; |
| if (--vi->usage == 0) |
| hlist_del(&vi->srv_link); |
| else |
| vi = NULL; |
| |
| write_unlock(&cbi->server->cb_break_lock); |
| kfree(vi); |
| afs_put_server(net, cbi->server); |
| } |
| kfree(cbi); |
| } |
| } |
| |
| /* |
| * allow the fileserver to request callback state (re-)initialisation |
| */ |
| void afs_init_callback_state(struct afs_server *server) |
| { |
| server->cb_s_break++; |
| } |
| |
| /* |
| * actually break a callback |
| */ |
| void __afs_break_callback(struct afs_vnode *vnode) |
| { |
| _enter(""); |
| |
| clear_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags); |
| if (test_and_clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) { |
| vnode->cb_break++; |
| afs_clear_permits(vnode); |
| |
| spin_lock(&vnode->lock); |
| |
| _debug("break callback"); |
| |
| if (list_empty(&vnode->granted_locks) && |
| !list_empty(&vnode->pending_locks)) |
| afs_lock_may_be_available(vnode); |
| spin_unlock(&vnode->lock); |
| } |
| } |
| |
| void afs_break_callback(struct afs_vnode *vnode) |
| { |
| write_seqlock(&vnode->cb_lock); |
| __afs_break_callback(vnode); |
| write_sequnlock(&vnode->cb_lock); |
| } |
| |
| /* |
| * allow the fileserver to explicitly break one callback |
| * - happens when |
| * - the backing file is changed |
| * - a lock is released |
| */ |
| static void afs_break_one_callback(struct afs_server *server, |
| struct afs_fid *fid) |
| { |
| struct afs_vol_interest *vi; |
| struct afs_cb_interest *cbi; |
| struct afs_iget_data data; |
| struct afs_vnode *vnode; |
| struct inode *inode; |
| |
| read_lock(&server->cb_break_lock); |
| hlist_for_each_entry(vi, &server->cb_volumes, srv_link) { |
| if (vi->vid < fid->vid) |
| continue; |
| if (vi->vid > fid->vid) { |
| vi = NULL; |
| break; |
| } |
| //atomic_inc(&vi->usage); |
| break; |
| } |
| |
| /* TODO: Find all matching volumes if we couldn't match the server and |
| * break them anyway. |
| */ |
| if (!vi) |
| goto out; |
| |
| /* Step through all interested superblocks. There may be more than one |
| * because of cell aliasing. |
| */ |
| hlist_for_each_entry(cbi, &vi->cb_interests, cb_vlink) { |
| if (fid->vnode == 0 && fid->unique == 0) { |
| /* The callback break applies to an entire volume. */ |
| struct afs_super_info *as = AFS_FS_S(cbi->sb); |
| struct afs_volume *volume = as->volume; |
| |
| write_lock(&volume->cb_break_lock); |
| volume->cb_v_break++; |
| write_unlock(&volume->cb_break_lock); |
| } else { |
| data.volume = NULL; |
| data.fid = *fid; |
| inode = ilookup5_nowait(cbi->sb, fid->vnode, |
| afs_iget5_test, &data); |
| if (inode) { |
| vnode = AFS_FS_I(inode); |
| afs_break_callback(vnode); |
| iput(inode); |
| } |
| } |
| } |
| |
| out: |
| read_unlock(&server->cb_break_lock); |
| } |
| |
| /* |
| * allow the fileserver to break callback promises |
| */ |
| void afs_break_callbacks(struct afs_server *server, size_t count, |
| struct afs_callback_break *callbacks) |
| { |
| _enter("%p,%zu,", server, count); |
| |
| ASSERT(server != NULL); |
| ASSERTCMP(count, <=, AFSCBMAX); |
| |
| /* TODO: Sort the callback break list by volume ID */ |
| |
| for (; count > 0; callbacks++, count--) { |
| _debug("- Fid { vl=%08llx n=%llu u=%u }", |
| callbacks->fid.vid, |
| callbacks->fid.vnode, |
| callbacks->fid.unique); |
| afs_break_one_callback(server, &callbacks->fid); |
| } |
| |
| _leave(""); |
| return; |
| } |
| |
| /* |
| * Clear the callback interests in a server list. |
| */ |
| void afs_clear_callback_interests(struct afs_net *net, struct afs_server_list *slist) |
| { |
| int i; |
| |
| for (i = 0; i < slist->nr_servers; i++) { |
| afs_put_cb_interest(net, slist->servers[i].cb_interest); |
| slist->servers[i].cb_interest = NULL; |
| } |
| } |