add new system file

hc

2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c

 kernel/fs/afs/callback.c
..
..
@@ -21,200 +21,25 @@
21
21
 #include "internal.h"
22
22
 
23
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);
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
-	if (vnode->cb_interest &&
98
-	    likely(vnode->cb_interest == entry->cb_interest))
99
-		return 0;
100
-
101
-	read_lock(&slist->lock);
102
-	cbi = afs_get_cb_interest(entry->cb_interest);
103
-	read_unlock(&slist->lock);
104
-
105
-	vcbi = vnode->cb_interest;
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 = vnode->cb_interest;
118
-			vnode->cb_interest = cbi;
119
-			write_sequnlock(&vnode->cb_lock);
120
-			afs_put_cb_interest(afs_v2net(vnode), old);
121
-			return 0;
122
-		}
123
-
124
-		/* Re-use the one attached to the vnode. */
125
-		if (!cbi && vcbi->server == server) {
126
-			write_lock(&slist->lock);
127
-			if (entry->cb_interest) {
128
-				write_unlock(&slist->lock);
129
-				afs_put_cb_interest(afs_v2net(vnode), cbi);
130
-				goto again;
131
-			}
132
-
133
-			entry->cb_interest = cbi;
134
-			write_unlock(&slist->lock);
135
-			return 0;
136
-		}
137
-	}
138
-
139
-	if (!cbi) {
140
-		new = afs_create_interest(server, vnode);
141
-		if (!new)
142
-			return -ENOMEM;
143
-
144
-		write_lock(&slist->lock);
145
-		if (!entry->cb_interest) {
146
-			entry->cb_interest = afs_get_cb_interest(new);
147
-			cbi = new;
148
-			new = NULL;
149
-		} else {
150
-			cbi = afs_get_cb_interest(entry->cb_interest);
151
-		}
152
-		write_unlock(&slist->lock);
153
-		afs_put_cb_interest(afs_v2net(vnode), new);
154
-	}
155
-
156
-	ASSERT(cbi);
157
-
158
-	/* Change the server the vnode is using.  This entails scrubbing any
159
-	 * interest the vnode had in the previous server it was using.
160
-	 */
161
-	write_seqlock(&vnode->cb_lock);
162
-
163
-	old = vnode->cb_interest;
164
-	vnode->cb_interest = cbi;
165
-	vnode->cb_s_break = cbi->server->cb_s_break;
166
-	vnode->cb_v_break = vnode->volume->cb_v_break;
167
-	clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags);
168
-
169
-	write_sequnlock(&vnode->cb_lock);
170
-	afs_put_cb_interest(afs_v2net(vnode), old);
171
-	return 0;
172
-}
173
-
174
-/*
175
- * Remove an interest on a server.
176
- */
177
-void afs_put_cb_interest(struct afs_net *net, struct afs_cb_interest *cbi)
178
-{
179
-	struct afs_vol_interest *vi;
180
-
181
-	if (cbi && refcount_dec_and_test(&cbi->usage)) {
182
-		if (!hlist_unhashed(&cbi->cb_vlink)) {
183
-			write_lock(&cbi->server->cb_break_lock);
184
-
185
-			hlist_del_init(&cbi->cb_vlink);
186
-			vi = cbi->vol_interest;
187
-			cbi->vol_interest = NULL;
188
-			if (--vi->usage == 0)
189
-				hlist_del(&vi->srv_link);
190
-			else
191
-				vi = NULL;
192
-
193
-			write_unlock(&cbi->server->cb_break_lock);
194
-			kfree(vi);
195
-			afs_put_server(net, cbi->server);
196
-		}
197
-		kfree(cbi);
198
-	}
199
-}
200
-
201
-/*
202
- * allow the fileserver to request callback state (re-)initialisation
24
+ * Allow the fileserver to request callback state (re-)initialisation.
25
+ * Unfortunately, UUIDs are not guaranteed unique.
203
26
  */
204
27
 void afs_init_callback_state(struct afs_server *server)
205
28
 {
206
-	if (!test_and_clear_bit(AFS_SERVER_FL_NEW, &server->flags))
29
+	rcu_read_lock();
30
+	do {
207
31
 		server->cb_s_break++;
32
+		server = rcu_dereference(server->uuid_next);
33
+	} while (0);
34
+	rcu_read_unlock();
208
35
 }
209
36
 
210
37
 /*
211
38
  * actually break a callback
212
39
  */
213
-void afs_break_callback(struct afs_vnode *vnode)
40
+void __afs_break_callback(struct afs_vnode *vnode, enum afs_cb_break_reason reason)
214
41
 {
215
42
 	_enter("");
216
-
217
-	write_seqlock(&vnode->cb_lock);
218
43
 
219
44
 	clear_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags);
220
45
 	if (test_and_clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) {
..
..
@@ -223,9 +48,54 @@
223
48
 
224
49
 		if (vnode->lock_state == AFS_VNODE_LOCK_WAITING_FOR_CB)
225
50
 			afs_lock_may_be_available(vnode);
226
-	}
227
51
 
52
+		trace_afs_cb_break(&vnode->fid, vnode->cb_break, reason, true);
53
+	} else {
54
+		trace_afs_cb_break(&vnode->fid, vnode->cb_break, reason, false);
55
+	}
56
+}
57
+
58
+void afs_break_callback(struct afs_vnode *vnode, enum afs_cb_break_reason reason)
59
+{
60
+	write_seqlock(&vnode->cb_lock);
61
+	__afs_break_callback(vnode, reason);
228
62
 	write_sequnlock(&vnode->cb_lock);
63
+}
64
+
65
+/*
66
+ * Look up a volume by volume ID under RCU conditions.
67
+ */
68
+static struct afs_volume *afs_lookup_volume_rcu(struct afs_cell *cell,
69
+						afs_volid_t vid)
70
+{
71
+	struct afs_volume *volume = NULL;
72
+	struct rb_node *p;
73
+	int seq = 0;
74
+
75
+	do {
76
+		/* Unfortunately, rbtree walking doesn't give reliable results
77
+		 * under just the RCU read lock, so we have to check for
78
+		 * changes.
79
+		 */
80
+		read_seqbegin_or_lock(&cell->volume_lock, &seq);
81
+
82
+		p = rcu_dereference_raw(cell->volumes.rb_node);
83
+		while (p) {
84
+			volume = rb_entry(p, struct afs_volume, cell_node);
85
+
86
+			if (volume->vid < vid)
87
+				p = rcu_dereference_raw(p->rb_left);
88
+			else if (volume->vid > vid)
89
+				p = rcu_dereference_raw(p->rb_right);
90
+			else
91
+				break;
92
+			volume = NULL;
93
+		}
94
+
95
+	} while (need_seqretry(&cell->volume_lock, seq));
96
+
97
+	done_seqretry(&cell->volume_lock, seq);
98
+	return volume;
229
99
 }
230
100
 
231
101
 /*
..
..
@@ -234,60 +104,68 @@
234
104
  *   - the backing file is changed
235
105
  *   - a lock is released
236
106
  */
237
-static void afs_break_one_callback(struct afs_server *server,
107
+static void afs_break_one_callback(struct afs_volume *volume,
238
108
 				   struct afs_fid *fid)
239
109
 {
240
-	struct afs_vol_interest *vi;
241
-	struct afs_cb_interest *cbi;
242
-	struct afs_iget_data data;
110
+	struct super_block *sb;
243
111
 	struct afs_vnode *vnode;
244
112
 	struct inode *inode;
245
113
 
246
-	read_lock(&server->cb_break_lock);
247
-	hlist_for_each_entry(vi, &server->cb_volumes, srv_link) {
248
-		if (vi->vid < fid->vid)
249
-			continue;
250
-		if (vi->vid > fid->vid) {
251
-			vi = NULL;
252
-			break;
253
-		}
254
-		//atomic_inc(&vi->usage);
255
-		break;
114
+	if (fid->vnode == 0 && fid->unique == 0) {
115
+		/* The callback break applies to an entire volume. */
116
+		write_lock(&volume->cb_v_break_lock);
117
+		volume->cb_v_break++;
118
+		trace_afs_cb_break(fid, volume->cb_v_break,
119
+				   afs_cb_break_for_volume_callback, false);
120
+		write_unlock(&volume->cb_v_break_lock);
121
+		return;
256
122
 	}
123
+
124
+	/* See if we can find a matching inode - even an I_NEW inode needs to
125
+	 * be marked as it can have its callback broken before we finish
126
+	 * setting up the local inode.
127
+	 */
128
+	sb = rcu_dereference(volume->sb);
129
+	if (!sb)
130
+		return;
131
+
132
+	inode = find_inode_rcu(sb, fid->vnode, afs_ilookup5_test_by_fid, fid);
133
+	if (inode) {
134
+		vnode = AFS_FS_I(inode);
135
+		afs_break_callback(vnode, afs_cb_break_for_callback);
136
+	} else {
137
+		trace_afs_cb_miss(fid, afs_cb_break_for_callback);
138
+	}
139
+}
140
+
141
+static void afs_break_some_callbacks(struct afs_server *server,
142
+				     struct afs_callback_break *cbb,
143
+				     size_t *_count)
144
+{
145
+	struct afs_callback_break *residue = cbb;
146
+	struct afs_volume *volume;
147
+	afs_volid_t vid = cbb->fid.vid;
148
+	size_t i;
149
+
150
+	volume = afs_lookup_volume_rcu(server->cell, vid);
257
151
 
258
152
 	/* TODO: Find all matching volumes if we couldn't match the server and
259
153
 	 * break them anyway.
260
154
 	 */
261
-	if (!vi)
262
-		goto out;
263
155
 
264
-	/* Step through all interested superblocks.  There may be more than one
265
-	 * because of cell aliasing.
266
-	 */
267
-	hlist_for_each_entry(cbi, &vi->cb_interests, cb_vlink) {
268
-		if (fid->vnode == 0 && fid->unique == 0) {
269
-			/* The callback break applies to an entire volume. */
270
-			struct afs_super_info *as = AFS_FS_S(cbi->sb);
271
-			struct afs_volume *volume = as->volume;
272
-
273
-			write_lock(&volume->cb_v_break_lock);
274
-			volume->cb_v_break++;
275
-			write_unlock(&volume->cb_v_break_lock);
156
+	for (i = *_count; i > 0; cbb++, i--) {
157
+		if (cbb->fid.vid == vid) {
158
+			_debug("- Fid { vl=%08llx n=%llu u=%u }",
159
+			       cbb->fid.vid,
160
+			       cbb->fid.vnode,
161
+			       cbb->fid.unique);
162
+			--*_count;
163
+			if (volume)
164
+				afs_break_one_callback(volume, &cbb->fid);
276
165
 		} else {
277
-			data.volume = NULL;
278
-			data.fid = *fid;
279
-			inode = ilookup5_nowait(cbi->sb, fid->vnode,
280
-						afs_iget5_test, &data);
281
-			if (inode) {
282
-				vnode = AFS_FS_I(inode);
283
-				afs_break_callback(vnode);
284
-				iput(inode);
285
-			}
166
+			*residue++ = *cbb;
286
167
 		}
287
168
 	}
288
-
289
-out:
290
-	read_unlock(&server->cb_break_lock);
291
169
 }
292
170
 
293
171
 /*
..
..
@@ -299,35 +177,12 @@
299
177
 	_enter("%p,%zu,", server, count);
300
178
 
301
179
 	ASSERT(server != NULL);
302
-	ASSERTCMP(count, <=, AFSCBMAX);
303
180
 
304
-	/* TODO: Sort the callback break list by volume ID */
181
+	rcu_read_lock();
305
182
 
306
-	for (; count > 0; callbacks++, count--) {
307
-		_debug("- Fid { vl=%08x n=%u u=%u }  CB { v=%u x=%u t=%u }",
308
-		       callbacks->fid.vid,
309
-		       callbacks->fid.vnode,
310
-		       callbacks->fid.unique,
311
-		       callbacks->cb.version,
312
-		       callbacks->cb.expiry,
313
-		       callbacks->cb.type
314
-		       );
315
-		afs_break_one_callback(server, &callbacks->fid);
316
-	}
183
+	while (count > 0)
184
+		afs_break_some_callbacks(server, callbacks, &count);
317
185
 
318
-	_leave("");
186
+	rcu_read_unlock();
319
187
 	return;
320
-}
321
-
322
-/*
323
- * Clear the callback interests in a server list.
324
- */
325
-void afs_clear_callback_interests(struct afs_net *net, struct afs_server_list *slist)
326
-{
327
-	int i;
328
-
329
-	for (i = 0; i < slist->nr_servers; i++) {
330
-		afs_put_cb_interest(net, slist->servers[i].cb_interest);
331
-		slist->servers[i].cb_interest = NULL;
332
-	}
333
188
 }