]>
Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
08e0e7c8 | 2 | * Copyright (c) 2002, 2007 Red Hat, Inc. All rights reserved. |
1da177e4 LT |
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 | * | |
44d1b980 | 11 | * Authors: David Woodhouse <dwmw2@infradead.org> |
1da177e4 LT |
12 | * David Howells <dhowells@redhat.com> |
13 | * | |
14 | */ | |
15 | ||
16 | #include <linux/kernel.h> | |
17 | #include <linux/module.h> | |
18 | #include <linux/init.h> | |
08e0e7c8 | 19 | #include <linux/circ_buf.h> |
e8edc6e0 | 20 | #include <linux/sched.h> |
1da177e4 | 21 | #include "internal.h" |
08e0e7c8 | 22 | |
6e0e99d5 DH |
23 | /* |
24 | * Handle invalidation of an mmap'd file. We invalidate all the PTEs referring | |
25 | * to the pages in this file's pagecache, forcing the kernel to go through | |
26 | * ->fault() or ->page_mkwrite() - at which point we can handle invalidation | |
27 | * more fully. | |
28 | */ | |
29 | void afs_invalidate_mmap_work(struct work_struct *work) | |
30 | { | |
31 | struct afs_vnode *vnode = container_of(work, struct afs_vnode, cb_work); | |
32 | ||
33 | unmap_mapping_pages(vnode->vfs_inode.i_mapping, 0, 0, false); | |
34 | } | |
35 | ||
36 | void afs_server_init_callback_work(struct work_struct *work) | |
37 | { | |
38 | struct afs_server *server = container_of(work, struct afs_server, initcb_work); | |
39 | struct afs_vnode *vnode; | |
40 | struct afs_cell *cell = server->cell; | |
41 | ||
42 | down_read(&cell->fs_open_mmaps_lock); | |
43 | ||
44 | list_for_each_entry(vnode, &cell->fs_open_mmaps, cb_mmap_link) { | |
45 | if (vnode->cb_server == server) { | |
46 | clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags); | |
47 | queue_work(system_unbound_wq, &vnode->cb_work); | |
48 | } | |
49 | } | |
50 | ||
51 | up_read(&cell->fs_open_mmaps_lock); | |
52 | } | |
53 | ||
c435ee34 | 54 | /* |
3c4c4075 DH |
55 | * Allow the fileserver to request callback state (re-)initialisation. |
56 | * Unfortunately, UUIDs are not guaranteed unique. | |
c435ee34 DH |
57 | */ |
58 | void afs_init_callback_state(struct afs_server *server) | |
59 | { | |
3c4c4075 DH |
60 | rcu_read_lock(); |
61 | do { | |
62 | server->cb_s_break++; | |
4fe6a946 | 63 | atomic_inc(&server->cell->fs_s_break); |
6e0e99d5 DH |
64 | if (!list_empty(&server->cell->fs_open_mmaps)) |
65 | queue_work(system_unbound_wq, &server->initcb_work); | |
66 | ||
67 | } while ((server = rcu_dereference(server->uuid_next))); | |
3c4c4075 | 68 | rcu_read_unlock(); |
08e0e7c8 DH |
69 | } |
70 | ||
71 | /* | |
72 | * actually break a callback | |
73 | */ | |
051d2525 | 74 | void __afs_break_callback(struct afs_vnode *vnode, enum afs_cb_break_reason reason) |
08e0e7c8 DH |
75 | { |
76 | _enter(""); | |
77 | ||
5a813276 | 78 | clear_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags); |
c435ee34 DH |
79 | if (test_and_clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) { |
80 | vnode->cb_break++; | |
4fe6a946 | 81 | vnode->cb_v_break = vnode->volume->cb_v_break; |
c435ee34 | 82 | afs_clear_permits(vnode); |
08e0e7c8 | 83 | |
c7226e40 | 84 | if (vnode->lock_state == AFS_VNODE_LOCK_WAITING_FOR_CB) |
e8d6c554 | 85 | afs_lock_may_be_available(vnode); |
051d2525 | 86 | |
6e0e99d5 DH |
87 | if (reason != afs_cb_break_for_deleted && |
88 | vnode->status.type == AFS_FTYPE_FILE && | |
89 | atomic_read(&vnode->cb_nr_mmap)) | |
90 | queue_work(system_unbound_wq, &vnode->cb_work); | |
91 | ||
051d2525 DH |
92 | trace_afs_cb_break(&vnode->fid, vnode->cb_break, reason, true); |
93 | } else { | |
94 | trace_afs_cb_break(&vnode->fid, vnode->cb_break, reason, false); | |
08e0e7c8 | 95 | } |
30062bd1 | 96 | } |
c435ee34 | 97 | |
051d2525 | 98 | void afs_break_callback(struct afs_vnode *vnode, enum afs_cb_break_reason reason) |
30062bd1 DH |
99 | { |
100 | write_seqlock(&vnode->cb_lock); | |
051d2525 | 101 | __afs_break_callback(vnode, reason); |
c435ee34 | 102 | write_sequnlock(&vnode->cb_lock); |
08e0e7c8 DH |
103 | } |
104 | ||
8230fd82 | 105 | /* |
20325960 | 106 | * Look up a volume by volume ID under RCU conditions. |
8230fd82 | 107 | */ |
20325960 DH |
108 | static struct afs_volume *afs_lookup_volume_rcu(struct afs_cell *cell, |
109 | afs_volid_t vid) | |
8230fd82 | 110 | { |
20325960 | 111 | struct afs_volume *volume = NULL; |
8230fd82 DH |
112 | struct rb_node *p; |
113 | int seq = 0; | |
114 | ||
115 | do { | |
116 | /* Unfortunately, rbtree walking doesn't give reliable results | |
117 | * under just the RCU read lock, so we have to check for | |
118 | * changes. | |
119 | */ | |
20325960 | 120 | read_seqbegin_or_lock(&cell->volume_lock, &seq); |
8230fd82 | 121 | |
20325960 | 122 | p = rcu_dereference_raw(cell->volumes.rb_node); |
8230fd82 | 123 | while (p) { |
20325960 | 124 | volume = rb_entry(p, struct afs_volume, cell_node); |
8230fd82 | 125 | |
20325960 | 126 | if (volume->vid < vid) |
8230fd82 | 127 | p = rcu_dereference_raw(p->rb_left); |
20325960 | 128 | else if (volume->vid > vid) |
8230fd82 DH |
129 | p = rcu_dereference_raw(p->rb_right); |
130 | else | |
131 | break; | |
20325960 | 132 | volume = NULL; |
8230fd82 DH |
133 | } |
134 | ||
20325960 | 135 | } while (need_seqretry(&cell->volume_lock, seq)); |
8230fd82 | 136 | |
20325960 DH |
137 | done_seqretry(&cell->volume_lock, seq); |
138 | return volume; | |
8230fd82 DH |
139 | } |
140 | ||
08e0e7c8 DH |
141 | /* |
142 | * allow the fileserver to explicitly break one callback | |
143 | * - happens when | |
144 | * - the backing file is changed | |
145 | * - a lock is released | |
146 | */ | |
20325960 DH |
147 | static void afs_break_one_callback(struct afs_volume *volume, |
148 | struct afs_fid *fid) | |
08e0e7c8 | 149 | { |
20325960 | 150 | struct super_block *sb; |
08e0e7c8 | 151 | struct afs_vnode *vnode; |
c435ee34 | 152 | struct inode *inode; |
08e0e7c8 | 153 | |
20325960 DH |
154 | if (fid->vnode == 0 && fid->unique == 0) { |
155 | /* The callback break applies to an entire volume. */ | |
156 | write_lock(&volume->cb_v_break_lock); | |
157 | volume->cb_v_break++; | |
158 | trace_afs_cb_break(fid, volume->cb_v_break, | |
159 | afs_cb_break_for_volume_callback, false); | |
160 | write_unlock(&volume->cb_v_break_lock); | |
161 | return; | |
162 | } | |
68251f0a | 163 | |
20325960 DH |
164 | /* See if we can find a matching inode - even an I_NEW inode needs to |
165 | * be marked as it can have its callback broken before we finish | |
166 | * setting up the local inode. | |
167 | */ | |
168 | sb = rcu_dereference(volume->sb); | |
169 | if (!sb) | |
170 | return; | |
171 | ||
172 | inode = find_inode_rcu(sb, fid->vnode, afs_ilookup5_test_by_fid, fid); | |
173 | if (inode) { | |
174 | vnode = AFS_FS_I(inode); | |
175 | afs_break_callback(vnode, afs_cb_break_for_callback); | |
176 | } else { | |
177 | trace_afs_cb_miss(fid, afs_cb_break_for_callback); | |
c435ee34 | 178 | } |
8230fd82 | 179 | } |
08e0e7c8 | 180 | |
8230fd82 DH |
181 | static void afs_break_some_callbacks(struct afs_server *server, |
182 | struct afs_callback_break *cbb, | |
183 | size_t *_count) | |
184 | { | |
185 | struct afs_callback_break *residue = cbb; | |
20325960 | 186 | struct afs_volume *volume; |
8230fd82 DH |
187 | afs_volid_t vid = cbb->fid.vid; |
188 | size_t i; | |
189 | ||
20325960 | 190 | volume = afs_lookup_volume_rcu(server->cell, vid); |
8230fd82 DH |
191 | |
192 | /* TODO: Find all matching volumes if we couldn't match the server and | |
193 | * break them anyway. | |
194 | */ | |
195 | ||
196 | for (i = *_count; i > 0; cbb++, i--) { | |
197 | if (cbb->fid.vid == vid) { | |
198 | _debug("- Fid { vl=%08llx n=%llu u=%u }", | |
199 | cbb->fid.vid, | |
200 | cbb->fid.vnode, | |
201 | cbb->fid.unique); | |
202 | --*_count; | |
20325960 DH |
203 | if (volume) |
204 | afs_break_one_callback(volume, &cbb->fid); | |
8230fd82 DH |
205 | } else { |
206 | *residue++ = *cbb; | |
207 | } | |
208 | } | |
ec26815a | 209 | } |
1da177e4 | 210 | |
1da177e4 LT |
211 | /* |
212 | * allow the fileserver to break callback promises | |
213 | */ | |
08e0e7c8 | 214 | void afs_break_callbacks(struct afs_server *server, size_t count, |
5cf9dd55 | 215 | struct afs_callback_break *callbacks) |
1da177e4 | 216 | { |
08e0e7c8 | 217 | _enter("%p,%zu,", server, count); |
1da177e4 | 218 | |
08e0e7c8 | 219 | ASSERT(server != NULL); |
1da177e4 | 220 | |
8230fd82 | 221 | rcu_read_lock(); |
68251f0a | 222 | |
8230fd82 DH |
223 | while (count > 0) |
224 | afs_break_some_callbacks(server, callbacks, &count); | |
08e0e7c8 | 225 | |
8230fd82 | 226 | rcu_read_unlock(); |
08e0e7c8 DH |
227 | return; |
228 | } |