1
2
3
4
5
6
7
8
9
10
11
12
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
23
24
25
26
27
28int afs_register_server_cb_interest(struct afs_vnode *vnode,
29 struct afs_server_list *slist,
30 unsigned int index)
31{
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;
35
36again:
37 if (vnode->cb_interest &&
38 likely(vnode->cb_interest == entry->cb_interest))
39 return 0;
40
41 read_lock(&slist->lock);
42 cbi = afs_get_cb_interest(entry->cb_interest);
43 read_unlock(&slist->lock);
44
45 vcbi = vnode->cb_interest;
46 if (vcbi) {
47 if (vcbi == cbi) {
48 afs_put_cb_interest(afs_v2net(vnode), cbi);
49 return 0;
50 }
51
52
53
54
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);
61 return 0;
62 }
63
64
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);
70 goto again;
71 }
72
73 entry->cb_interest = cbi;
74 write_unlock(&slist->lock);
75 return 0;
76 }
77 }
78
79 if (!cbi) {
80 new = kzalloc(sizeof(struct afs_cb_interest), GFP_KERNEL);
81 if (!new)
82 return -ENOMEM;
83
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);
89
90 write_lock(&server->cb_break_lock);
91 list_add_tail(&new->cb_link, &server->cb_interests);
92 write_unlock(&server->cb_break_lock);
93
94 write_lock(&slist->lock);
95 if (!entry->cb_interest) {
96 entry->cb_interest = afs_get_cb_interest(new);
97 cbi = new;
98 new = NULL;
99 } else {
100 cbi = afs_get_cb_interest(entry->cb_interest);
101 }
102 write_unlock(&slist->lock);
103 afs_put_cb_interest(afs_v2net(vnode), new);
104 }
105
106 ASSERT(cbi);
107
108
109
110
111 write_seqlock(&vnode->cb_lock);
112
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);
118
119 write_sequnlock(&vnode->cb_lock);
120 afs_put_cb_interest(afs_v2net(vnode), old);
121 return 0;
122}
123
124
125
126
127void afs_put_cb_interest(struct afs_net *net, struct afs_cb_interest *cbi)
128{
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);
135 }
136 kfree(cbi);
137 }
138}
139
140
141
142
143void afs_init_callback_state(struct afs_server *server)
144{
145 if (!test_and_clear_bit(AFS_SERVER_FL_NEW, &server->flags))
146 server->cb_s_break++;
147}
148
149
150
151
152void afs_break_callback(struct afs_vnode *vnode)
153{
154 _enter("");
155
156 write_seqlock(&vnode->cb_lock);
157
158 clear_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags);
159 if (test_and_clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) {
160 vnode->cb_break++;
161 afs_clear_permits(vnode);
162
163 spin_lock(&vnode->lock);
164
165 _debug("break callback");
166
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);
171 }
172
173 write_sequnlock(&vnode->cb_lock);
174}
175
176
177
178
179
180
181
182static void afs_break_one_callback(struct afs_server *server,
183 struct afs_fid *fid)
184{
185 struct afs_cb_interest *cbi;
186 struct afs_iget_data data;
187 struct afs_vnode *vnode;
188 struct inode *inode;
189
190 read_lock(&server->cb_break_lock);
191
192
193
194
195 list_for_each_entry(cbi, &server->cb_interests, cb_link) {
196 if (cbi->vid != fid->vid)
197 continue;
198
199 if (fid->vnode == 0 && fid->unique == 0) {
200
201 struct afs_super_info *as = AFS_FS_S(cbi->sb);
202 struct afs_volume *volume = as->volume;
203
204 write_lock(&volume->cb_break_lock);
205 volume->cb_v_break++;
206 write_unlock(&volume->cb_break_lock);
207 } else {
208 data.volume = NULL;
209 data.fid = *fid;
210 inode = ilookup5_nowait(cbi->sb, fid->vnode,
211 afs_iget5_test, &data);
212 if (inode) {
213 vnode = AFS_FS_I(inode);
214 afs_break_callback(vnode);
215 iput(inode);
216 }
217 }
218 }
219
220 read_unlock(&server->cb_break_lock);
221}
222
223
224
225
226void afs_break_callbacks(struct afs_server *server, size_t count,
227 struct afs_callback_break *callbacks)
228{
229 _enter("%p,%zu,", server, count);
230
231 ASSERT(server != NULL);
232 ASSERTCMP(count, <=, AFSCBMAX);
233
234
235
236 for (; count > 0; callbacks++, count--) {
237 _debug("- Fid { vl=%08x n=%u u=%u } CB { v=%u x=%u t=%u }",
238 callbacks->fid.vid,
239 callbacks->fid.vnode,
240 callbacks->fid.unique,
241 callbacks->cb.version,
242 callbacks->cb.expiry,
243 callbacks->cb.type
244 );
245 afs_break_one_callback(server, &callbacks->fid);
246 }
247
248 _leave("");
249 return;
250}
251
252
253
254
255void afs_clear_callback_interests(struct afs_net *net, struct afs_server_list *slist)
256{
257 int i;
258
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;
262 }
263}
264