2 * Copyright (c) 2002, 2007 Red Hat, Inc. All rights reserved.
4 * This software may be freely redistributed under the terms of the
5 * GNU General Public License.
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.
11 * Authors: David Woodhouse <dwmw2@infradead.org>
12 * David Howells <dhowells@redhat.com>
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>
24 * Set up an interest-in-callbacks record for a volume on a server and
25 * register it with the server.
26 * - Called with vnode->io_lock held.
28 int afs_register_server_cb_interest(struct afs_vnode *vnode,
29 struct afs_server_list *slist,
32 struct afs_server_entry *entry = &slist->servers[index];
33 struct afs_cb_interest *cbi, *vcbi, *new, *old;
34 struct afs_server *server = entry->server;
37 if (vnode->cb_interest &&
38 likely(vnode->cb_interest == entry->cb_interest))
41 read_lock(&slist->lock);
42 cbi = afs_get_cb_interest(entry->cb_interest);
43 read_unlock(&slist->lock);
45 vcbi = vnode->cb_interest;
48 afs_put_cb_interest(afs_v2net(vnode), cbi);
52 /* Use a new interest in the server list for the same server
53 * rather than an old one that's still attached to a vnode.
55 if (cbi && vcbi->server == cbi->server) {
56 write_seqlock(&vnode->cb_lock);
57 old = vnode->cb_interest;
58 vnode->cb_interest = cbi;
59 write_sequnlock(&vnode->cb_lock);
60 afs_put_cb_interest(afs_v2net(vnode), old);
64 /* Re-use the one attached to the vnode. */
65 if (!cbi && vcbi->server == server) {
66 write_lock(&slist->lock);
67 if (entry->cb_interest) {
68 write_unlock(&slist->lock);
69 afs_put_cb_interest(afs_v2net(vnode), cbi);
73 entry->cb_interest = cbi;
74 write_unlock(&slist->lock);
80 new = kzalloc(sizeof(struct afs_cb_interest), GFP_KERNEL);
84 refcount_set(&new->usage, 1);
85 new->sb = vnode->vfs_inode.i_sb;
86 new->vid = vnode->volume->vid;
87 new->server = afs_get_server(server);
88 INIT_LIST_HEAD(&new->cb_link);
90 write_lock(&server->cb_break_lock);
91 list_add_tail(&new->cb_link, &server->cb_interests);
92 write_unlock(&server->cb_break_lock);
94 write_lock(&slist->lock);
95 if (!entry->cb_interest) {
96 entry->cb_interest = afs_get_cb_interest(new);
100 cbi = afs_get_cb_interest(entry->cb_interest);
102 write_unlock(&slist->lock);
103 afs_put_cb_interest(afs_v2net(vnode), new);
108 /* Change the server the vnode is using. This entails scrubbing any
109 * interest the vnode had in the previous server it was using.
111 write_seqlock(&vnode->cb_lock);
113 old = vnode->cb_interest;
114 vnode->cb_interest = cbi;
115 vnode->cb_s_break = cbi->server->cb_s_break;
116 vnode->cb_v_break = vnode->volume->cb_v_break;
117 clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags);
119 write_sequnlock(&vnode->cb_lock);
120 afs_put_cb_interest(afs_v2net(vnode), old);
125 * Remove an interest on a server.
127 void afs_put_cb_interest(struct afs_net *net, struct afs_cb_interest *cbi)
129 if (cbi && refcount_dec_and_test(&cbi->usage)) {
130 if (!list_empty(&cbi->cb_link)) {
131 write_lock(&cbi->server->cb_break_lock);
132 list_del_init(&cbi->cb_link);
133 write_unlock(&cbi->server->cb_break_lock);
134 afs_put_server(net, cbi->server);
141 * allow the fileserver to request callback state (re-)initialisation
143 void afs_init_callback_state(struct afs_server *server)
145 if (!test_and_clear_bit(AFS_SERVER_FL_NEW, &server->flags))
146 server->cb_s_break++;
150 * actually break a callback
152 void afs_break_callback(struct afs_vnode *vnode)
156 write_seqlock(&vnode->cb_lock);
158 clear_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags);
159 if (test_and_clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) {
161 afs_clear_permits(vnode);
163 spin_lock(&vnode->lock);
165 _debug("break callback");
167 if (list_empty(&vnode->granted_locks) &&
168 !list_empty(&vnode->pending_locks))
169 afs_lock_may_be_available(vnode);
170 spin_unlock(&vnode->lock);
173 write_sequnlock(&vnode->cb_lock);
177 * allow the fileserver to explicitly break one callback
179 * - the backing file is changed
180 * - a lock is released
182 static void afs_break_one_callback(struct afs_server *server,
185 struct afs_cb_interest *cbi;
186 struct afs_iget_data data;
187 struct afs_vnode *vnode;
190 read_lock(&server->cb_break_lock);
192 /* Step through all interested superblocks. There may be more than one
193 * because of cell aliasing.
195 list_for_each_entry(cbi, &server->cb_interests, cb_link) {
196 if (cbi->vid != fid->vid)
199 if (fid->vnode == 0 && fid->unique == 0) {
200 /* The callback break applies to an entire volume. */
201 struct afs_super_info *as = AFS_FS_S(cbi->sb);
202 struct afs_volume *volume = as->volume;
204 write_lock(&volume->cb_break_lock);
205 volume->cb_v_break++;
206 write_unlock(&volume->cb_break_lock);
210 inode = ilookup5_nowait(cbi->sb, fid->vnode,
211 afs_iget5_test, &data);
213 vnode = AFS_FS_I(inode);
214 afs_break_callback(vnode);
220 read_unlock(&server->cb_break_lock);
224 * allow the fileserver to break callback promises
226 void afs_break_callbacks(struct afs_server *server, size_t count,
227 struct afs_callback_break *callbacks)
229 _enter("%p,%zu,", server, count);
231 ASSERT(server != NULL);
232 ASSERTCMP(count, <=, AFSCBMAX);
234 /* TODO: Sort the callback break list by volume ID */
236 for (; count > 0; callbacks++, count--) {
237 _debug("- Fid { vl=%08x n=%u u=%u } CB { v=%u x=%u t=%u }",
239 callbacks->fid.vnode,
240 callbacks->fid.unique,
241 callbacks->cb.version,
242 callbacks->cb.expiry,
245 afs_break_one_callback(server, &callbacks->fid);
253 * Clear the callback interests in a server list.
255 void afs_clear_callback_interests(struct afs_net *net, struct afs_server_list *slist)
259 for (i = 0; i < slist->nr_servers; i++) {
260 afs_put_cb_interest(net, slist->servers[i].cb_interest);
261 slist->servers[i].cb_interest = NULL;