~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/afs/callback.c

Version: ~ [ linux-5.12-rc1 ] ~ [ linux-5.11.2 ] ~ [ linux-5.10.19 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.101 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.177 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.222 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.258 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.258 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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@infradead.org>
 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 
 23 /*
 24  * Create volume and callback interests on a server.
 25  */
 26 static struct afs_cb_interest *afs_create_interest(struct afs_server *server,
 27                                                    struct afs_vnode *vnode)
 28 {
 29         struct afs_vol_interest *new_vi, *vi;
 30         struct afs_cb_interest *new;
 31         struct hlist_node **pp;
 32 
 33         new_vi = kzalloc(sizeof(struct afs_vol_interest), GFP_KERNEL);
 34         if (!new_vi)
 35                 return NULL;
 36 
 37         new = kzalloc(sizeof(struct afs_cb_interest), GFP_KERNEL);
 38         if (!new) {
 39                 kfree(new_vi);
 40                 return NULL;
 41         }
 42 
 43         new_vi->usage = 1;
 44         new_vi->vid = vnode->volume->vid;
 45         INIT_HLIST_NODE(&new_vi->srv_link);
 46         INIT_HLIST_HEAD(&new_vi->cb_interests);
 47 
 48         refcount_set(&new->usage, 1);
 49         new->sb = vnode->vfs_inode.i_sb;
 50         new->vid = vnode->volume->vid;
 51         new->server = afs_get_server(server, afs_server_trace_get_new_cbi);
 52         INIT_HLIST_NODE(&new->cb_vlink);
 53 
 54         write_lock(&server->cb_break_lock);
 55 
 56         for (pp = &server->cb_volumes.first; *pp; pp = &(*pp)->next) {
 57                 vi = hlist_entry(*pp, struct afs_vol_interest, srv_link);
 58                 if (vi->vid < new_vi->vid)
 59                         continue;
 60                 if (vi->vid > new_vi->vid)
 61                         break;
 62                 vi->usage++;
 63                 goto found_vi;
 64         }
 65 
 66         new_vi->srv_link.pprev = pp;
 67         new_vi->srv_link.next = *pp;
 68         if (*pp)
 69                 (*pp)->pprev = &new_vi->srv_link.next;
 70         *pp = &new_vi->srv_link;
 71         vi = new_vi;
 72         new_vi = NULL;
 73 found_vi:
 74 
 75         new->vol_interest = vi;
 76         hlist_add_head(&new->cb_vlink, &vi->cb_interests);
 77 
 78         write_unlock(&server->cb_break_lock);
 79         kfree(new_vi);
 80         return new;
 81 }
 82 
 83 /*
 84  * Set up an interest-in-callbacks record for a volume on a server and
 85  * register it with the server.
 86  * - Called with vnode->io_lock held.
 87  */
 88 int afs_register_server_cb_interest(struct afs_vnode *vnode,
 89                                     struct afs_server_list *slist,
 90                                     unsigned int index)
 91 {
 92         struct afs_server_entry *entry = &slist->servers[index];
 93         struct afs_cb_interest *cbi, *vcbi, *new, *old;
 94         struct afs_server *server = entry->server;
 95 
 96 again:
 97         vcbi = rcu_dereference_protected(vnode->cb_interest,
 98                                          lockdep_is_held(&vnode->io_lock));
 99         if (vcbi && likely(vcbi == entry->cb_interest))
100                 return 0;
101 
102         read_lock(&slist->lock);
103         cbi = afs_get_cb_interest(entry->cb_interest);
104         read_unlock(&slist->lock);
105 
106         if (vcbi) {
107                 if (vcbi == cbi) {
108                         afs_put_cb_interest(afs_v2net(vnode), cbi);
109                         return 0;
110                 }
111 
112                 /* Use a new interest in the server list for the same server
113                  * rather than an old one that's still attached to a vnode.
114                  */
115                 if (cbi && vcbi->server == cbi->server) {
116                         write_seqlock(&vnode->cb_lock);
117                         old = rcu_dereference_protected(vnode->cb_interest,
118                                                         lockdep_is_held(&vnode->cb_lock.lock));
119                         rcu_assign_pointer(vnode->cb_interest, cbi);
120                         write_sequnlock(&vnode->cb_lock);
121                         afs_put_cb_interest(afs_v2net(vnode), old);
122                         return 0;
123                 }
124 
125                 /* Re-use the one attached to the vnode. */
126                 if (!cbi && vcbi->server == server) {
127                         write_lock(&slist->lock);
128                         if (entry->cb_interest) {
129                                 write_unlock(&slist->lock);
130                                 afs_put_cb_interest(afs_v2net(vnode), cbi);
131                                 goto again;
132                         }
133 
134                         entry->cb_interest = cbi;
135                         write_unlock(&slist->lock);
136                         return 0;
137                 }
138         }
139 
140         if (!cbi) {
141                 new = afs_create_interest(server, vnode);
142                 if (!new)
143                         return -ENOMEM;
144 
145                 write_lock(&slist->lock);
146                 if (!entry->cb_interest) {
147                         entry->cb_interest = afs_get_cb_interest(new);
148                         cbi = new;
149                         new = NULL;
150                 } else {
151                         cbi = afs_get_cb_interest(entry->cb_interest);
152                 }
153                 write_unlock(&slist->lock);
154                 afs_put_cb_interest(afs_v2net(vnode), new);
155         }
156 
157         ASSERT(cbi);
158 
159         /* Change the server the vnode is using.  This entails scrubbing any
160          * interest the vnode had in the previous server it was using.
161          */
162         write_seqlock(&vnode->cb_lock);
163 
164         old = rcu_dereference_protected(vnode->cb_interest,
165                                         lockdep_is_held(&vnode->cb_lock.lock));
166         rcu_assign_pointer(vnode->cb_interest, cbi);
167         vnode->cb_s_break = cbi->server->cb_s_break;
168         vnode->cb_v_break = vnode->volume->cb_v_break;
169         clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags);
170 
171         write_sequnlock(&vnode->cb_lock);
172         afs_put_cb_interest(afs_v2net(vnode), old);
173         return 0;
174 }
175 
176 /*
177  * Remove an interest on a server.
178  */
179 void afs_put_cb_interest(struct afs_net *net, struct afs_cb_interest *cbi)
180 {
181         struct afs_vol_interest *vi;
182 
183         if (cbi && refcount_dec_and_test(&cbi->usage)) {
184                 if (!hlist_unhashed(&cbi->cb_vlink)) {
185                         write_lock(&cbi->server->cb_break_lock);
186 
187                         hlist_del_init(&cbi->cb_vlink);
188                         vi = cbi->vol_interest;
189                         cbi->vol_interest = NULL;
190                         if (--vi->usage == 0)
191                                 hlist_del(&vi->srv_link);
192                         else
193                                 vi = NULL;
194 
195                         write_unlock(&cbi->server->cb_break_lock);
196                         if (vi)
197                                 kfree_rcu(vi, rcu);
198                         afs_put_server(net, cbi->server, afs_server_trace_put_cbi);
199                 }
200                 kfree_rcu(cbi, rcu);
201         }
202 }
203 
204 /*
205  * allow the fileserver to request callback state (re-)initialisation
206  */
207 void afs_init_callback_state(struct afs_server *server)
208 {
209         server->cb_s_break++;
210 }
211 
212 /*
213  * actually break a callback
214  */
215 void __afs_break_callback(struct afs_vnode *vnode, enum afs_cb_break_reason reason)
216 {
217         _enter("");
218 
219         clear_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags);
220         if (test_and_clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) {
221                 vnode->cb_break++;
222                 afs_clear_permits(vnode);
223 
224                 if (vnode->lock_state == AFS_VNODE_LOCK_WAITING_FOR_CB)
225                         afs_lock_may_be_available(vnode);
226 
227                 trace_afs_cb_break(&vnode->fid, vnode->cb_break, reason, true);
228         } else {
229                 trace_afs_cb_break(&vnode->fid, vnode->cb_break, reason, false);
230         }
231 }
232 
233 void afs_break_callback(struct afs_vnode *vnode, enum afs_cb_break_reason reason)
234 {
235         write_seqlock(&vnode->cb_lock);
236         __afs_break_callback(vnode, reason);
237         write_sequnlock(&vnode->cb_lock);
238 }
239 
240 /*
241  * allow the fileserver to explicitly break one callback
242  * - happens when
243  *   - the backing file is changed
244  *   - a lock is released
245  */
246 static void afs_break_one_callback(struct afs_server *server,
247                                    struct afs_fid *fid)
248 {
249         struct afs_vol_interest *vi;
250         struct afs_cb_interest *cbi;
251         struct afs_iget_data data;
252         struct afs_vnode *vnode;
253         struct inode *inode;
254 
255         read_lock(&server->cb_break_lock);
256         hlist_for_each_entry(vi, &server->cb_volumes, srv_link) {
257                 if (vi->vid < fid->vid)
258                         continue;
259                 if (vi->vid > fid->vid) {
260                         vi = NULL;
261                         break;
262                 }
263                 //atomic_inc(&vi->usage);
264                 break;
265         }
266 
267         /* TODO: Find all matching volumes if we couldn't match the server and
268          * break them anyway.
269          */
270         if (!vi)
271                 goto out;
272 
273         /* Step through all interested superblocks.  There may be more than one
274          * because of cell aliasing.
275          */
276         hlist_for_each_entry(cbi, &vi->cb_interests, cb_vlink) {
277                 if (fid->vnode == 0 && fid->unique == 0) {
278                         /* The callback break applies to an entire volume. */
279                         struct afs_super_info *as = AFS_FS_S(cbi->sb);
280                         struct afs_volume *volume = as->volume;
281 
282                         write_lock(&volume->cb_v_break_lock);
283                         volume->cb_v_break++;
284                         trace_afs_cb_break(fid, volume->cb_v_break,
285                                            afs_cb_break_for_volume_callback, false);
286                         write_unlock(&volume->cb_v_break_lock);
287                 } else {
288                         data.volume = NULL;
289                         data.fid = *fid;
290                         inode = ilookup5_nowait(cbi->sb, fid->vnode,
291                                                 afs_iget5_test, &data);
292                         if (inode) {
293                                 vnode = AFS_FS_I(inode);
294                                 afs_break_callback(vnode, afs_cb_break_for_callback);
295                                 iput(inode);
296                         } else {
297                                 trace_afs_cb_miss(fid, afs_cb_break_for_callback);
298                         }
299                 }
300         }
301 
302 out:
303         read_unlock(&server->cb_break_lock);
304 }
305 
306 /*
307  * allow the fileserver to break callback promises
308  */
309 void afs_break_callbacks(struct afs_server *server, size_t count,
310                          struct afs_callback_break *callbacks)
311 {
312         _enter("%p,%zu,", server, count);
313 
314         ASSERT(server != NULL);
315         ASSERTCMP(count, <=, AFSCBMAX);
316 
317         /* TODO: Sort the callback break list by volume ID */
318 
319         for (; count > 0; callbacks++, count--) {
320                 _debug("- Fid { vl=%08llx n=%llu u=%u }",
321                        callbacks->fid.vid,
322                        callbacks->fid.vnode,
323                        callbacks->fid.unique);
324                 afs_break_one_callback(server, &callbacks->fid);
325         }
326 
327         _leave("");
328         return;
329 }
330 
331 /*
332  * Clear the callback interests in a server list.
333  */
334 void afs_clear_callback_interests(struct afs_net *net, struct afs_server_list *slist)
335 {
336         int i;
337 
338         for (i = 0; i < slist->nr_servers; i++) {
339                 afs_put_cb_interest(net, slist->servers[i].cb_interest);
340                 slist->servers[i].cb_interest = NULL;
341         }
342 }
343 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp