Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
3d14c5d2 | 2 | #include <linux/ceph/ceph_debug.h> |
963b61eb | 3 | |
a68e564a | 4 | #include <linux/fs.h> |
963b61eb | 5 | #include <linux/sort.h> |
5a0e3ad6 | 6 | #include <linux/slab.h> |
176c77c9 | 7 | #include <linux/iversion.h> |
963b61eb | 8 | #include "super.h" |
3d14c5d2 | 9 | #include "mds_client.h" |
3d14c5d2 | 10 | #include <linux/ceph/decode.h> |
963b61eb | 11 | |
75c9627e YZ |
12 | /* unused map expires after 5 minutes */ |
13 | #define CEPH_SNAPID_MAP_TIMEOUT (5 * 60 * HZ) | |
14 | ||
963b61eb SW |
15 | /* |
16 | * Snapshots in ceph are driven in large part by cooperation from the | |
17 | * client. In contrast to local file systems or file servers that | |
18 | * implement snapshots at a single point in the system, ceph's | |
19 | * distributed access to storage requires clients to help decide | |
20 | * whether a write logically occurs before or after a recently created | |
21 | * snapshot. | |
22 | * | |
23 | * This provides a perfect instantanous client-wide snapshot. Between | |
24 | * clients, however, snapshots may appear to be applied at slightly | |
25 | * different points in time, depending on delays in delivering the | |
26 | * snapshot notification. | |
27 | * | |
28 | * Snapshots are _not_ file system-wide. Instead, each snapshot | |
29 | * applies to the subdirectory nested beneath some directory. This | |
30 | * effectively divides the hierarchy into multiple "realms," where all | |
31 | * of the files contained by each realm share the same set of | |
32 | * snapshots. An individual realm's snap set contains snapshots | |
33 | * explicitly created on that realm, as well as any snaps in its | |
34 | * parent's snap set _after_ the point at which the parent became it's | |
35 | * parent (due to, say, a rename). Similarly, snaps from prior parents | |
36 | * during the time intervals during which they were the parent are included. | |
37 | * | |
38 | * The client is spared most of this detail, fortunately... it must only | |
39 | * maintains a hierarchy of realms reflecting the current parent/child | |
40 | * realm relationship, and for each realm has an explicit list of snaps | |
41 | * inherited from prior parents. | |
42 | * | |
43 | * A snap_realm struct is maintained for realms containing every inode | |
44 | * with an open cap in the system. (The needed snap realm information is | |
45 | * provided by the MDS whenever a cap is issued, i.e., on open.) A 'seq' | |
46 | * version number is used to ensure that as realm parameters change (new | |
47 | * snapshot, new parent, etc.) the client's realm hierarchy is updated. | |
48 | * | |
49 | * The realm hierarchy drives the generation of a 'snap context' for each | |
50 | * realm, which simply lists the resulting set of snaps for the realm. This | |
51 | * is attached to any writes sent to OSDs. | |
52 | */ | |
53 | /* | |
54 | * Unfortunately error handling is a bit mixed here. If we get a snap | |
55 | * update, but don't have enough memory to update our realm hierarchy, | |
56 | * it's not clear what we can do about it (besides complaining to the | |
57 | * console). | |
58 | */ | |
59 | ||
60 | ||
61 | /* | |
62 | * increase ref count for the realm | |
63 | * | |
df2c0cb7 | 64 | * caller must hold snap_rwsem. |
963b61eb SW |
65 | */ |
66 | void ceph_get_snap_realm(struct ceph_mds_client *mdsc, | |
67 | struct ceph_snap_realm *realm) | |
68 | { | |
df2c0cb7 | 69 | lockdep_assert_held(&mdsc->snap_rwsem); |
a6862e67 | 70 | |
963b61eb | 71 | /* |
8434ffe7 JL |
72 | * The 0->1 and 1->0 transitions must take the snap_empty_lock |
73 | * atomically with the refcount change. Go ahead and bump the | |
74 | * nref here, unless it's 0, in which case we take the spinlock | |
75 | * and then do the increment and remove it from the list. | |
963b61eb | 76 | */ |
8434ffe7 JL |
77 | if (atomic_inc_not_zero(&realm->nref)) |
78 | return; | |
79 | ||
80 | spin_lock(&mdsc->snap_empty_lock); | |
81 | if (atomic_inc_return(&realm->nref) == 1) | |
963b61eb | 82 | list_del_init(&realm->empty_item); |
8434ffe7 | 83 | spin_unlock(&mdsc->snap_empty_lock); |
963b61eb SW |
84 | } |
85 | ||
a105f00c SW |
86 | static void __insert_snap_realm(struct rb_root *root, |
87 | struct ceph_snap_realm *new) | |
88 | { | |
89 | struct rb_node **p = &root->rb_node; | |
90 | struct rb_node *parent = NULL; | |
91 | struct ceph_snap_realm *r = NULL; | |
92 | ||
93 | while (*p) { | |
94 | parent = *p; | |
95 | r = rb_entry(parent, struct ceph_snap_realm, node); | |
96 | if (new->ino < r->ino) | |
97 | p = &(*p)->rb_left; | |
98 | else if (new->ino > r->ino) | |
99 | p = &(*p)->rb_right; | |
100 | else | |
101 | BUG(); | |
102 | } | |
103 | ||
104 | rb_link_node(&new->node, parent, p); | |
105 | rb_insert_color(&new->node, root); | |
106 | } | |
107 | ||
963b61eb SW |
108 | /* |
109 | * create and get the realm rooted at @ino and bump its ref count. | |
110 | * | |
111 | * caller must hold snap_rwsem for write. | |
112 | */ | |
113 | static struct ceph_snap_realm *ceph_create_snap_realm( | |
114 | struct ceph_mds_client *mdsc, | |
115 | u64 ino) | |
116 | { | |
117 | struct ceph_snap_realm *realm; | |
118 | ||
a6862e67 JL |
119 | lockdep_assert_held_write(&mdsc->snap_rwsem); |
120 | ||
963b61eb SW |
121 | realm = kzalloc(sizeof(*realm), GFP_NOFS); |
122 | if (!realm) | |
123 | return ERR_PTR(-ENOMEM); | |
124 | ||
5ed91587 XL |
125 | /* Do not release the global dummy snaprealm until unmouting */ |
126 | if (ino == CEPH_INO_GLOBAL_SNAPREALM) | |
127 | atomic_set(&realm->nref, 2); | |
128 | else | |
129 | atomic_set(&realm->nref, 1); | |
963b61eb SW |
130 | realm->ino = ino; |
131 | INIT_LIST_HEAD(&realm->children); | |
132 | INIT_LIST_HEAD(&realm->child_item); | |
133 | INIT_LIST_HEAD(&realm->empty_item); | |
ae00d4f3 | 134 | INIT_LIST_HEAD(&realm->dirty_item); |
74a31df4 | 135 | INIT_LIST_HEAD(&realm->rebuild_item); |
963b61eb SW |
136 | INIT_LIST_HEAD(&realm->inodes_with_caps); |
137 | spin_lock_init(&realm->inodes_with_caps_lock); | |
a105f00c | 138 | __insert_snap_realm(&mdsc->snap_realms, realm); |
81c5a148 YZ |
139 | mdsc->num_snap_realms++; |
140 | ||
ad5255c1 | 141 | dout("%s %llx %p\n", __func__, realm->ino, realm); |
963b61eb SW |
142 | return realm; |
143 | } | |
144 | ||
145 | /* | |
a105f00c | 146 | * lookup the realm rooted at @ino. |
963b61eb | 147 | * |
df2c0cb7 | 148 | * caller must hold snap_rwsem. |
963b61eb | 149 | */ |
982d6011 YZ |
150 | static struct ceph_snap_realm *__lookup_snap_realm(struct ceph_mds_client *mdsc, |
151 | u64 ino) | |
963b61eb | 152 | { |
a105f00c SW |
153 | struct rb_node *n = mdsc->snap_realms.rb_node; |
154 | struct ceph_snap_realm *r; | |
155 | ||
df2c0cb7 | 156 | lockdep_assert_held(&mdsc->snap_rwsem); |
a6862e67 | 157 | |
a105f00c SW |
158 | while (n) { |
159 | r = rb_entry(n, struct ceph_snap_realm, node); | |
160 | if (ino < r->ino) | |
161 | n = n->rb_left; | |
162 | else if (ino > r->ino) | |
163 | n = n->rb_right; | |
164 | else { | |
ad5255c1 | 165 | dout("%s %llx %p\n", __func__, r->ino, r); |
a105f00c SW |
166 | return r; |
167 | } | |
168 | } | |
169 | return NULL; | |
963b61eb SW |
170 | } |
171 | ||
982d6011 YZ |
172 | struct ceph_snap_realm *ceph_lookup_snap_realm(struct ceph_mds_client *mdsc, |
173 | u64 ino) | |
174 | { | |
175 | struct ceph_snap_realm *r; | |
176 | r = __lookup_snap_realm(mdsc, ino); | |
177 | if (r) | |
178 | ceph_get_snap_realm(mdsc, r); | |
179 | return r; | |
180 | } | |
181 | ||
963b61eb SW |
182 | static void __put_snap_realm(struct ceph_mds_client *mdsc, |
183 | struct ceph_snap_realm *realm); | |
184 | ||
185 | /* | |
186 | * called with snap_rwsem (write) | |
187 | */ | |
188 | static void __destroy_snap_realm(struct ceph_mds_client *mdsc, | |
189 | struct ceph_snap_realm *realm) | |
190 | { | |
a6862e67 JL |
191 | lockdep_assert_held_write(&mdsc->snap_rwsem); |
192 | ||
ad5255c1 | 193 | dout("%s %p %llx\n", __func__, realm, realm->ino); |
963b61eb | 194 | |
a105f00c | 195 | rb_erase(&realm->node, &mdsc->snap_realms); |
81c5a148 | 196 | mdsc->num_snap_realms--; |
963b61eb SW |
197 | |
198 | if (realm->parent) { | |
199 | list_del_init(&realm->child_item); | |
200 | __put_snap_realm(mdsc, realm->parent); | |
201 | } | |
202 | ||
203 | kfree(realm->prior_parent_snaps); | |
204 | kfree(realm->snaps); | |
205 | ceph_put_snap_context(realm->cached_context); | |
206 | kfree(realm); | |
207 | } | |
208 | ||
209 | /* | |
210 | * caller holds snap_rwsem (write) | |
211 | */ | |
212 | static void __put_snap_realm(struct ceph_mds_client *mdsc, | |
213 | struct ceph_snap_realm *realm) | |
214 | { | |
a6862e67 JL |
215 | lockdep_assert_held_write(&mdsc->snap_rwsem); |
216 | ||
8434ffe7 JL |
217 | /* |
218 | * We do not require the snap_empty_lock here, as any caller that | |
219 | * increments the value must hold the snap_rwsem. | |
220 | */ | |
963b61eb SW |
221 | if (atomic_dec_and_test(&realm->nref)) |
222 | __destroy_snap_realm(mdsc, realm); | |
223 | } | |
224 | ||
225 | /* | |
8434ffe7 | 226 | * See comments in ceph_get_snap_realm. Caller needn't hold any locks. |
963b61eb SW |
227 | */ |
228 | void ceph_put_snap_realm(struct ceph_mds_client *mdsc, | |
229 | struct ceph_snap_realm *realm) | |
230 | { | |
8434ffe7 | 231 | if (!atomic_dec_and_lock(&realm->nref, &mdsc->snap_empty_lock)) |
963b61eb SW |
232 | return; |
233 | ||
234 | if (down_write_trylock(&mdsc->snap_rwsem)) { | |
8434ffe7 | 235 | spin_unlock(&mdsc->snap_empty_lock); |
963b61eb SW |
236 | __destroy_snap_realm(mdsc, realm); |
237 | up_write(&mdsc->snap_rwsem); | |
238 | } else { | |
a26a185d | 239 | list_add(&realm->empty_item, &mdsc->snap_empty); |
963b61eb SW |
240 | spin_unlock(&mdsc->snap_empty_lock); |
241 | } | |
242 | } | |
243 | ||
244 | /* | |
245 | * Clean up any realms whose ref counts have dropped to zero. Note | |
246 | * that this does not include realms who were created but not yet | |
247 | * used. | |
248 | * | |
249 | * Called under snap_rwsem (write) | |
250 | */ | |
251 | static void __cleanup_empty_realms(struct ceph_mds_client *mdsc) | |
252 | { | |
253 | struct ceph_snap_realm *realm; | |
254 | ||
a6862e67 JL |
255 | lockdep_assert_held_write(&mdsc->snap_rwsem); |
256 | ||
963b61eb SW |
257 | spin_lock(&mdsc->snap_empty_lock); |
258 | while (!list_empty(&mdsc->snap_empty)) { | |
259 | realm = list_first_entry(&mdsc->snap_empty, | |
260 | struct ceph_snap_realm, empty_item); | |
261 | list_del(&realm->empty_item); | |
262 | spin_unlock(&mdsc->snap_empty_lock); | |
263 | __destroy_snap_realm(mdsc, realm); | |
264 | spin_lock(&mdsc->snap_empty_lock); | |
265 | } | |
266 | spin_unlock(&mdsc->snap_empty_lock); | |
267 | } | |
268 | ||
5ed91587 | 269 | void ceph_cleanup_global_and_empty_realms(struct ceph_mds_client *mdsc) |
963b61eb | 270 | { |
5ed91587 XL |
271 | struct ceph_snap_realm *global_realm; |
272 | ||
963b61eb | 273 | down_write(&mdsc->snap_rwsem); |
5ed91587 XL |
274 | global_realm = __lookup_snap_realm(mdsc, CEPH_INO_GLOBAL_SNAPREALM); |
275 | if (global_realm) | |
276 | ceph_put_snap_realm(mdsc, global_realm); | |
963b61eb SW |
277 | __cleanup_empty_realms(mdsc); |
278 | up_write(&mdsc->snap_rwsem); | |
279 | } | |
280 | ||
281 | /* | |
282 | * adjust the parent realm of a given @realm. adjust child list, and parent | |
283 | * pointers, and ref counts appropriately. | |
284 | * | |
285 | * return true if parent was changed, 0 if unchanged, <0 on error. | |
286 | * | |
287 | * caller must hold snap_rwsem for write. | |
288 | */ | |
289 | static int adjust_snap_realm_parent(struct ceph_mds_client *mdsc, | |
290 | struct ceph_snap_realm *realm, | |
291 | u64 parentino) | |
292 | { | |
293 | struct ceph_snap_realm *parent; | |
294 | ||
a6862e67 JL |
295 | lockdep_assert_held_write(&mdsc->snap_rwsem); |
296 | ||
963b61eb SW |
297 | if (realm->parent_ino == parentino) |
298 | return 0; | |
299 | ||
300 | parent = ceph_lookup_snap_realm(mdsc, parentino); | |
963b61eb SW |
301 | if (!parent) { |
302 | parent = ceph_create_snap_realm(mdsc, parentino); | |
303 | if (IS_ERR(parent)) | |
304 | return PTR_ERR(parent); | |
305 | } | |
ad5255c1 XL |
306 | dout("%s %llx %p: %llx %p -> %llx %p\n", __func__, realm->ino, |
307 | realm, realm->parent_ino, realm->parent, parentino, parent); | |
963b61eb SW |
308 | if (realm->parent) { |
309 | list_del_init(&realm->child_item); | |
310 | ceph_put_snap_realm(mdsc, realm->parent); | |
311 | } | |
312 | realm->parent_ino = parentino; | |
313 | realm->parent = parent; | |
963b61eb SW |
314 | list_add(&realm->child_item, &parent->children); |
315 | return 1; | |
316 | } | |
317 | ||
318 | ||
319 | static int cmpu64_rev(const void *a, const void *b) | |
320 | { | |
321 | if (*(u64 *)a < *(u64 *)b) | |
322 | return 1; | |
323 | if (*(u64 *)a > *(u64 *)b) | |
324 | return -1; | |
325 | return 0; | |
326 | } | |
327 | ||
97c85a82 | 328 | |
963b61eb SW |
329 | /* |
330 | * build the snap context for a given realm. | |
331 | */ | |
3ae0bebc | 332 | static int build_snap_context(struct ceph_snap_realm *realm, |
74a31df4 XL |
333 | struct list_head *realm_queue, |
334 | struct list_head *dirty_realms) | |
963b61eb SW |
335 | { |
336 | struct ceph_snap_realm *parent = realm->parent; | |
337 | struct ceph_snap_context *snapc; | |
338 | int err = 0; | |
aa711ee3 | 339 | u32 num = realm->num_prior_parent_snaps + realm->num_snaps; |
963b61eb SW |
340 | |
341 | /* | |
342 | * build parent context, if it hasn't been built. | |
343 | * conservatively estimate that all parent snaps might be | |
344 | * included by us. | |
345 | */ | |
346 | if (parent) { | |
347 | if (!parent->cached_context) { | |
74a31df4 XL |
348 | /* add to the queue head */ |
349 | list_add(&parent->rebuild_item, realm_queue); | |
350 | return 1; | |
963b61eb SW |
351 | } |
352 | num += parent->cached_context->num_snaps; | |
353 | } | |
354 | ||
355 | /* do i actually need to update? not if my context seq | |
356 | matches realm seq, and my parents' does to. (this works | |
357 | because we rebuild_snap_realms() works _downward_ in | |
358 | hierarchy after each update.) */ | |
359 | if (realm->cached_context && | |
ec4318bc | 360 | realm->cached_context->seq == realm->seq && |
963b61eb | 361 | (!parent || |
ec4318bc | 362 | realm->cached_context->seq >= parent->cached_context->seq)) { |
ad5255c1 XL |
363 | dout("%s %llx %p: %p seq %lld (%u snaps) (unchanged)\n", |
364 | __func__, realm->ino, realm, realm->cached_context, | |
963b61eb | 365 | realm->cached_context->seq, |
3ae0bebc | 366 | (unsigned int)realm->cached_context->num_snaps); |
963b61eb SW |
367 | return 0; |
368 | } | |
369 | ||
370 | /* alloc new snap context */ | |
371 | err = -ENOMEM; | |
a3860c1c | 372 | if (num > (SIZE_MAX - sizeof(*snapc)) / sizeof(u64)) |
963b61eb | 373 | goto fail; |
812164f8 | 374 | snapc = ceph_create_snap_context(num, GFP_NOFS); |
963b61eb SW |
375 | if (!snapc) |
376 | goto fail; | |
963b61eb SW |
377 | |
378 | /* build (reverse sorted) snap vector */ | |
379 | num = 0; | |
380 | snapc->seq = realm->seq; | |
381 | if (parent) { | |
aa711ee3 AE |
382 | u32 i; |
383 | ||
25985edc | 384 | /* include any of parent's snaps occurring _after_ my |
963b61eb SW |
385 | parent became my parent */ |
386 | for (i = 0; i < parent->cached_context->num_snaps; i++) | |
387 | if (parent->cached_context->snaps[i] >= | |
388 | realm->parent_since) | |
389 | snapc->snaps[num++] = | |
390 | parent->cached_context->snaps[i]; | |
391 | if (parent->cached_context->seq > snapc->seq) | |
392 | snapc->seq = parent->cached_context->seq; | |
393 | } | |
394 | memcpy(snapc->snaps + num, realm->snaps, | |
395 | sizeof(u64)*realm->num_snaps); | |
396 | num += realm->num_snaps; | |
397 | memcpy(snapc->snaps + num, realm->prior_parent_snaps, | |
398 | sizeof(u64)*realm->num_prior_parent_snaps); | |
399 | num += realm->num_prior_parent_snaps; | |
400 | ||
401 | sort(snapc->snaps, num, sizeof(u64), cmpu64_rev, NULL); | |
402 | snapc->num_snaps = num; | |
ad5255c1 XL |
403 | dout("%s %llx %p: %p seq %lld (%u snaps)\n", __func__, realm->ino, |
404 | realm, snapc, snapc->seq, (unsigned int) snapc->num_snaps); | |
963b61eb | 405 | |
9f4057fc | 406 | ceph_put_snap_context(realm->cached_context); |
963b61eb | 407 | realm->cached_context = snapc; |
9f4057fc YZ |
408 | /* queue realm for cap_snap creation */ |
409 | list_add_tail(&realm->dirty_item, dirty_realms); | |
963b61eb SW |
410 | return 0; |
411 | ||
412 | fail: | |
413 | /* | |
414 | * if we fail, clear old (incorrect) cached_context... hopefully | |
415 | * we'll have better luck building it later | |
416 | */ | |
417 | if (realm->cached_context) { | |
418 | ceph_put_snap_context(realm->cached_context); | |
419 | realm->cached_context = NULL; | |
420 | } | |
ad5255c1 | 421 | pr_err("%s %llx %p fail %d\n", __func__, realm->ino, realm, err); |
963b61eb SW |
422 | return err; |
423 | } | |
424 | ||
425 | /* | |
426 | * rebuild snap context for the given realm and all of its children. | |
427 | */ | |
3ae0bebc YZ |
428 | static void rebuild_snap_realms(struct ceph_snap_realm *realm, |
429 | struct list_head *dirty_realms) | |
963b61eb | 430 | { |
74a31df4 XL |
431 | LIST_HEAD(realm_queue); |
432 | int last = 0; | |
433 | bool skip = false; | |
434 | ||
435 | list_add_tail(&realm->rebuild_item, &realm_queue); | |
436 | ||
437 | while (!list_empty(&realm_queue)) { | |
438 | struct ceph_snap_realm *_realm, *child; | |
439 | ||
440 | _realm = list_first_entry(&realm_queue, | |
441 | struct ceph_snap_realm, | |
442 | rebuild_item); | |
443 | ||
444 | /* | |
445 | * If the last building failed dues to memory | |
446 | * issue, just empty the realm_queue and return | |
447 | * to avoid infinite loop. | |
448 | */ | |
449 | if (last < 0) { | |
450 | list_del_init(&_realm->rebuild_item); | |
451 | continue; | |
452 | } | |
453 | ||
454 | last = build_snap_context(_realm, &realm_queue, dirty_realms); | |
ad5255c1 | 455 | dout("%s %llx %p, %s\n", __func__, _realm->ino, _realm, |
74a31df4 XL |
456 | last > 0 ? "is deferred" : !last ? "succeeded" : "failed"); |
457 | ||
458 | /* is any child in the list ? */ | |
459 | list_for_each_entry(child, &_realm->children, child_item) { | |
460 | if (!list_empty(&child->rebuild_item)) { | |
461 | skip = true; | |
462 | break; | |
463 | } | |
464 | } | |
963b61eb | 465 | |
74a31df4 XL |
466 | if (!skip) { |
467 | list_for_each_entry(child, &_realm->children, child_item) | |
468 | list_add_tail(&child->rebuild_item, &realm_queue); | |
469 | } | |
963b61eb | 470 | |
74a31df4 XL |
471 | /* last == 1 means need to build parent first */ |
472 | if (last <= 0) | |
473 | list_del_init(&_realm->rebuild_item); | |
474 | } | |
963b61eb SW |
475 | } |
476 | ||
477 | ||
478 | /* | |
479 | * helper to allocate and decode an array of snapids. free prior | |
480 | * instance, if any. | |
481 | */ | |
aa711ee3 | 482 | static int dup_array(u64 **dst, __le64 *src, u32 num) |
963b61eb | 483 | { |
aa711ee3 | 484 | u32 i; |
963b61eb SW |
485 | |
486 | kfree(*dst); | |
487 | if (num) { | |
488 | *dst = kcalloc(num, sizeof(u64), GFP_NOFS); | |
489 | if (!*dst) | |
490 | return -ENOMEM; | |
491 | for (i = 0; i < num; i++) | |
492 | (*dst)[i] = get_unaligned_le64(src + i); | |
493 | } else { | |
494 | *dst = NULL; | |
495 | } | |
496 | return 0; | |
497 | } | |
498 | ||
86056090 YZ |
499 | static bool has_new_snaps(struct ceph_snap_context *o, |
500 | struct ceph_snap_context *n) | |
501 | { | |
502 | if (n->num_snaps == 0) | |
503 | return false; | |
504 | /* snaps are in descending order */ | |
505 | return n->snaps[0] > o->seq; | |
506 | } | |
963b61eb SW |
507 | |
508 | /* | |
509 | * When a snapshot is applied, the size/mtime inode metadata is queued | |
510 | * in a ceph_cap_snap (one for each snapshot) until writeback | |
511 | * completes and the metadata can be flushed back to the MDS. | |
512 | * | |
513 | * However, if a (sync) write is currently in-progress when we apply | |
514 | * the snapshot, we have to wait until the write succeeds or fails | |
515 | * (and a final size/mtime is known). In this case the | |
516 | * cap_snap->writing = 1, and is said to be "pending." When the write | |
517 | * finishes, we __ceph_finish_cap_snap(). | |
518 | * | |
519 | * Caller must hold snap_rwsem for read (i.e., the realm topology won't | |
520 | * change). | |
521 | */ | |
1ab36c9d XL |
522 | static void ceph_queue_cap_snap(struct ceph_inode_info *ci, |
523 | struct ceph_cap_snap **pcapsnap) | |
963b61eb | 524 | { |
874c8ca1 | 525 | struct inode *inode = &ci->netfs.inode; |
86056090 | 526 | struct ceph_snap_context *old_snapc, *new_snapc; |
1ab36c9d | 527 | struct ceph_cap_snap *capsnap = *pcapsnap; |
12fe3dda | 528 | struct ceph_buffer *old_blob = NULL; |
4a625be4 | 529 | int used, dirty; |
963b61eb | 530 | |
be655596 | 531 | spin_lock(&ci->i_ceph_lock); |
963b61eb | 532 | used = __ceph_caps_used(ci); |
4a625be4 | 533 | dirty = __ceph_caps_dirty(ci); |
af0ed569 | 534 | |
5dda377c | 535 | old_snapc = ci->i_head_snapc; |
86056090 | 536 | new_snapc = ci->i_snap_realm->cached_context; |
5dda377c | 537 | |
af0ed569 SW |
538 | /* |
539 | * If there is a write in progress, treat that as a dirty Fw, | |
540 | * even though it hasn't completed yet; by the time we finish | |
541 | * up this capsnap it will be. | |
542 | */ | |
543 | if (used & CEPH_CAP_FILE_WR) | |
544 | dirty |= CEPH_CAP_FILE_WR; | |
545 | ||
963b61eb SW |
546 | if (__ceph_have_pending_cap_snap(ci)) { |
547 | /* there is no point in queuing multiple "pending" cap_snaps, | |
548 | as no new writes are allowed to start when pending, so any | |
549 | writes in progress now were started before the previous | |
550 | cap_snap. lucky us. */ | |
ad5255c1 XL |
551 | dout("%s %p %llx.%llx already pending\n", |
552 | __func__, inode, ceph_vinop(inode)); | |
5dda377c YZ |
553 | goto update_snapc; |
554 | } | |
86056090 YZ |
555 | if (ci->i_wrbuffer_ref_head == 0 && |
556 | !(dirty & (CEPH_CAP_ANY_EXCL|CEPH_CAP_FILE_WR))) { | |
ad5255c1 XL |
557 | dout("%s %p %llx.%llx nothing dirty|writing\n", |
558 | __func__, inode, ceph_vinop(inode)); | |
5dda377c YZ |
559 | goto update_snapc; |
560 | } | |
963b61eb | 561 | |
5dda377c | 562 | BUG_ON(!old_snapc); |
e20d258d | 563 | |
86056090 YZ |
564 | /* |
565 | * There is no need to send FLUSHSNAP message to MDS if there is | |
566 | * no new snapshot. But when there is dirty pages or on-going | |
567 | * writes, we still need to create cap_snap. cap_snap is needed | |
568 | * by the write path and page writeback path. | |
569 | * | |
570 | * also see ceph_try_drop_cap_snap() | |
571 | */ | |
572 | if (has_new_snaps(old_snapc, new_snapc)) { | |
573 | if (dirty & (CEPH_CAP_ANY_EXCL|CEPH_CAP_FILE_WR)) | |
574 | capsnap->need_flush = true; | |
575 | } else { | |
576 | if (!(used & CEPH_CAP_FILE_WR) && | |
577 | ci->i_wrbuffer_ref_head == 0) { | |
ad5255c1 XL |
578 | dout("%s %p %llx.%llx no new_snap|dirty_page|writing\n", |
579 | __func__, inode, ceph_vinop(inode)); | |
86056090 YZ |
580 | goto update_snapc; |
581 | } | |
582 | } | |
583 | ||
ad5255c1 XL |
584 | dout("%s %p %llx.%llx cap_snap %p queuing under %p %s %s\n", |
585 | __func__, inode, ceph_vinop(inode), capsnap, old_snapc, | |
586 | ceph_cap_string(dirty), capsnap->need_flush ? "" : "no_flush"); | |
5dda377c YZ |
587 | ihold(inode); |
588 | ||
5dda377c YZ |
589 | capsnap->follows = old_snapc->seq; |
590 | capsnap->issued = __ceph_caps_issued(ci, NULL); | |
591 | capsnap->dirty = dirty; | |
592 | ||
593 | capsnap->mode = inode->i_mode; | |
594 | capsnap->uid = inode->i_uid; | |
595 | capsnap->gid = inode->i_gid; | |
596 | ||
597 | if (dirty & CEPH_CAP_XATTR_EXCL) { | |
12fe3dda | 598 | old_blob = __ceph_build_xattrs_blob(ci); |
5dda377c YZ |
599 | capsnap->xattr_blob = |
600 | ceph_buffer_get(ci->i_xattrs.blob); | |
601 | capsnap->xattr_version = ci->i_xattrs.version; | |
963b61eb | 602 | } else { |
5dda377c YZ |
603 | capsnap->xattr_blob = NULL; |
604 | capsnap->xattr_version = 0; | |
963b61eb SW |
605 | } |
606 | ||
5dda377c YZ |
607 | capsnap->inline_data = ci->i_inline_version != CEPH_INLINE_NONE; |
608 | ||
609 | /* dirty page count moved from _head to this cap_snap; | |
610 | all subsequent writes page dirties occur _after_ this | |
611 | snapshot. */ | |
612 | capsnap->dirty_pages = ci->i_wrbuffer_ref_head; | |
613 | ci->i_wrbuffer_ref_head = 0; | |
614 | capsnap->context = old_snapc; | |
615 | list_add_tail(&capsnap->ci_item, &ci->i_cap_snaps); | |
5dda377c YZ |
616 | |
617 | if (used & CEPH_CAP_FILE_WR) { | |
ad5255c1 XL |
618 | dout("%s %p %llx.%llx cap_snap %p snapc %p seq %llu used WR," |
619 | " now pending\n", __func__, inode, ceph_vinop(inode), | |
5dda377c YZ |
620 | capsnap, old_snapc, old_snapc->seq); |
621 | capsnap->writing = 1; | |
622 | } else { | |
623 | /* note mtime, size NOW. */ | |
624 | __ceph_finish_cap_snap(ci, capsnap); | |
625 | } | |
1ab36c9d | 626 | *pcapsnap = NULL; |
fce85157 | 627 | old_snapc = NULL; |
5dda377c YZ |
628 | |
629 | update_snapc: | |
ad5255c1 XL |
630 | if (ci->i_wrbuffer_ref_head == 0 && |
631 | ci->i_wr_ref == 0 && | |
632 | ci->i_dirty_caps == 0 && | |
633 | ci->i_flushing_caps == 0) { | |
634 | ci->i_head_snapc = NULL; | |
635 | } else { | |
86056090 YZ |
636 | ci->i_head_snapc = ceph_get_snap_context(new_snapc); |
637 | dout(" new snapc is %p\n", new_snapc); | |
5dda377c | 638 | } |
be655596 | 639 | spin_unlock(&ci->i_ceph_lock); |
5dda377c | 640 | |
12fe3dda | 641 | ceph_buffer_put(old_blob); |
5dda377c | 642 | ceph_put_snap_context(old_snapc); |
963b61eb SW |
643 | } |
644 | ||
645 | /* | |
646 | * Finalize the size, mtime for a cap_snap.. that is, settle on final values | |
647 | * to be used for the snapshot, to be flushed back to the mds. | |
648 | * | |
649 | * If capsnap can now be flushed, add to snap_flush list, and return 1. | |
650 | * | |
be655596 | 651 | * Caller must hold i_ceph_lock. |
963b61eb SW |
652 | */ |
653 | int __ceph_finish_cap_snap(struct ceph_inode_info *ci, | |
654 | struct ceph_cap_snap *capsnap) | |
655 | { | |
874c8ca1 | 656 | struct inode *inode = &ci->netfs.inode; |
2678da88 | 657 | struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb); |
963b61eb SW |
658 | |
659 | BUG_ON(capsnap->writing); | |
2d6795fb | 660 | capsnap->size = i_size_read(inode); |
9bbeab41 AB |
661 | capsnap->mtime = inode->i_mtime; |
662 | capsnap->atime = inode->i_atime; | |
663 | capsnap->ctime = inode->i_ctime; | |
ec62b894 | 664 | capsnap->btime = ci->i_btime; |
176c77c9 | 665 | capsnap->change_attr = inode_peek_iversion_raw(inode); |
963b61eb | 666 | capsnap->time_warp_seq = ci->i_time_warp_seq; |
5f743e45 YZ |
667 | capsnap->truncate_size = ci->i_truncate_size; |
668 | capsnap->truncate_seq = ci->i_truncate_seq; | |
963b61eb | 669 | if (capsnap->dirty_pages) { |
ad5255c1 XL |
670 | dout("%s %p %llx.%llx cap_snap %p snapc %p %llu %s s=%llu " |
671 | "still has %d dirty pages\n", __func__, inode, | |
672 | ceph_vinop(inode), capsnap, capsnap->context, | |
673 | capsnap->context->seq, ceph_cap_string(capsnap->dirty), | |
674 | capsnap->size, capsnap->dirty_pages); | |
963b61eb SW |
675 | return 0; |
676 | } | |
70220ac8 | 677 | |
558b4510 XL |
678 | /* Fb cap still in use, delay it */ |
679 | if (ci->i_wb_ref) { | |
ad5255c1 XL |
680 | dout("%s %p %llx.%llx cap_snap %p snapc %p %llu %s s=%llu " |
681 | "used WRBUFFER, delaying\n", __func__, inode, | |
682 | ceph_vinop(inode), capsnap, capsnap->context, | |
683 | capsnap->context->seq, ceph_cap_string(capsnap->dirty), | |
684 | capsnap->size); | |
558b4510 XL |
685 | capsnap->writing = 1; |
686 | return 0; | |
687 | } | |
688 | ||
70220ac8 | 689 | ci->i_ceph_flags |= CEPH_I_FLUSH_SNAPS; |
ad5255c1 XL |
690 | dout("%s %p %llx.%llx cap_snap %p snapc %p %llu %s s=%llu\n", |
691 | __func__, inode, ceph_vinop(inode), capsnap, capsnap->context, | |
819ccbfa SW |
692 | capsnap->context->seq, ceph_cap_string(capsnap->dirty), |
693 | capsnap->size); | |
963b61eb SW |
694 | |
695 | spin_lock(&mdsc->snap_flush_lock); | |
04242ff3 YZ |
696 | if (list_empty(&ci->i_snap_flush_item)) |
697 | list_add_tail(&ci->i_snap_flush_item, &mdsc->snap_flush_list); | |
963b61eb SW |
698 | spin_unlock(&mdsc->snap_flush_lock); |
699 | return 1; /* caller may want to ceph_flush_snaps */ | |
700 | } | |
701 | ||
ed326044 SW |
702 | /* |
703 | * Queue cap_snaps for snap writeback for this realm and its children. | |
704 | * Called under snap_rwsem, so realm topology won't change. | |
705 | */ | |
706 | static void queue_realm_cap_snaps(struct ceph_snap_realm *realm) | |
707 | { | |
708 | struct ceph_inode_info *ci; | |
709 | struct inode *lastinode = NULL; | |
1ab36c9d | 710 | struct ceph_cap_snap *capsnap = NULL; |
ed326044 | 711 | |
ad5255c1 | 712 | dout("%s %p %llx inode\n", __func__, realm, realm->ino); |
ed326044 SW |
713 | |
714 | spin_lock(&realm->inodes_with_caps_lock); | |
3ae0bebc | 715 | list_for_each_entry(ci, &realm->inodes_with_caps, i_snap_realm_item) { |
874c8ca1 | 716 | struct inode *inode = igrab(&ci->netfs.inode); |
ed326044 SW |
717 | if (!inode) |
718 | continue; | |
719 | spin_unlock(&realm->inodes_with_caps_lock); | |
23c2c76e | 720 | iput(lastinode); |
ed326044 | 721 | lastinode = inode; |
1ab36c9d XL |
722 | |
723 | /* | |
724 | * Allocate the capsnap memory outside of ceph_queue_cap_snap() | |
725 | * to reduce very possible but unnecessary frequently memory | |
726 | * allocate/free in this loop. | |
727 | */ | |
728 | if (!capsnap) { | |
729 | capsnap = kmem_cache_zalloc(ceph_cap_snap_cachep, GFP_NOFS); | |
730 | if (!capsnap) { | |
731 | pr_err("ENOMEM allocating ceph_cap_snap on %p\n", | |
732 | inode); | |
733 | return; | |
734 | } | |
735 | } | |
736 | capsnap->cap_flush.is_capsnap = true; | |
737 | refcount_set(&capsnap->nref, 1); | |
738 | INIT_LIST_HEAD(&capsnap->cap_flush.i_list); | |
739 | INIT_LIST_HEAD(&capsnap->cap_flush.g_list); | |
740 | INIT_LIST_HEAD(&capsnap->ci_item); | |
741 | ||
742 | ceph_queue_cap_snap(ci, &capsnap); | |
ed326044 SW |
743 | spin_lock(&realm->inodes_with_caps_lock); |
744 | } | |
745 | spin_unlock(&realm->inodes_with_caps_lock); | |
23c2c76e | 746 | iput(lastinode); |
ed326044 | 747 | |
1ab36c9d XL |
748 | if (capsnap) |
749 | kmem_cache_free(ceph_cap_snap_cachep, capsnap); | |
ad5255c1 | 750 | dout("%s %p %llx done\n", __func__, realm, realm->ino); |
ed326044 | 751 | } |
963b61eb SW |
752 | |
753 | /* | |
754 | * Parse and apply a snapblob "snap trace" from the MDS. This specifies | |
755 | * the snap realm parameters from a given realm and all of its ancestors, | |
756 | * up to the root. | |
757 | * | |
758 | * Caller must hold snap_rwsem for write. | |
759 | */ | |
760 | int ceph_update_snap_trace(struct ceph_mds_client *mdsc, | |
982d6011 YZ |
761 | void *p, void *e, bool deletion, |
762 | struct ceph_snap_realm **realm_ret) | |
963b61eb SW |
763 | { |
764 | struct ceph_mds_snap_realm *ri; /* encoded */ | |
765 | __le64 *snaps; /* encoded */ | |
766 | __le64 *prior_parent_snaps; /* encoded */ | |
51884d15 | 767 | struct ceph_snap_realm *realm; |
982d6011 | 768 | struct ceph_snap_realm *first_realm = NULL; |
2e586641 | 769 | struct ceph_snap_realm *realm_to_rebuild = NULL; |
a68e564a | 770 | struct ceph_client *client = mdsc->fsc->client; |
2e586641 | 771 | int rebuild_snapcs; |
963b61eb | 772 | int err = -ENOMEM; |
a68e564a | 773 | int ret; |
ae00d4f3 | 774 | LIST_HEAD(dirty_realms); |
963b61eb | 775 | |
a6862e67 JL |
776 | lockdep_assert_held_write(&mdsc->snap_rwsem); |
777 | ||
ad5255c1 | 778 | dout("%s deletion=%d\n", __func__, deletion); |
963b61eb | 779 | more: |
51884d15 | 780 | realm = NULL; |
2e586641 | 781 | rebuild_snapcs = 0; |
963b61eb SW |
782 | ceph_decode_need(&p, e, sizeof(*ri), bad); |
783 | ri = p; | |
784 | p += sizeof(*ri); | |
785 | ceph_decode_need(&p, e, sizeof(u64)*(le32_to_cpu(ri->num_snaps) + | |
786 | le32_to_cpu(ri->num_prior_parent_snaps)), bad); | |
787 | snaps = p; | |
788 | p += sizeof(u64) * le32_to_cpu(ri->num_snaps); | |
789 | prior_parent_snaps = p; | |
790 | p += sizeof(u64) * le32_to_cpu(ri->num_prior_parent_snaps); | |
791 | ||
792 | realm = ceph_lookup_snap_realm(mdsc, le64_to_cpu(ri->ino)); | |
963b61eb SW |
793 | if (!realm) { |
794 | realm = ceph_create_snap_realm(mdsc, le64_to_cpu(ri->ino)); | |
795 | if (IS_ERR(realm)) { | |
796 | err = PTR_ERR(realm); | |
797 | goto fail; | |
798 | } | |
799 | } | |
800 | ||
963b61eb SW |
801 | /* ensure the parent is correct */ |
802 | err = adjust_snap_realm_parent(mdsc, realm, le64_to_cpu(ri->parent)); | |
803 | if (err < 0) | |
804 | goto fail; | |
2e586641 | 805 | rebuild_snapcs += err; |
963b61eb SW |
806 | |
807 | if (le64_to_cpu(ri->seq) > realm->seq) { | |
ad5255c1 | 808 | dout("%s updating %llx %p %lld -> %lld\n", __func__, |
ae00d4f3 | 809 | realm->ino, realm, realm->seq, le64_to_cpu(ri->seq)); |
963b61eb SW |
810 | /* update realm parameters, snap lists */ |
811 | realm->seq = le64_to_cpu(ri->seq); | |
812 | realm->created = le64_to_cpu(ri->created); | |
813 | realm->parent_since = le64_to_cpu(ri->parent_since); | |
814 | ||
815 | realm->num_snaps = le32_to_cpu(ri->num_snaps); | |
816 | err = dup_array(&realm->snaps, snaps, realm->num_snaps); | |
817 | if (err < 0) | |
818 | goto fail; | |
819 | ||
820 | realm->num_prior_parent_snaps = | |
821 | le32_to_cpu(ri->num_prior_parent_snaps); | |
822 | err = dup_array(&realm->prior_parent_snaps, prior_parent_snaps, | |
823 | realm->num_prior_parent_snaps); | |
824 | if (err < 0) | |
825 | goto fail; | |
826 | ||
affbc19a YZ |
827 | if (realm->seq > mdsc->last_snap_seq) |
828 | mdsc->last_snap_seq = realm->seq; | |
ae00d4f3 | 829 | |
2e586641 | 830 | rebuild_snapcs = 1; |
963b61eb | 831 | } else if (!realm->cached_context) { |
ad5255c1 | 832 | dout("%s %llx %p seq %lld new\n", __func__, |
ae00d4f3 | 833 | realm->ino, realm, realm->seq); |
2e586641 | 834 | rebuild_snapcs = 1; |
ae00d4f3 | 835 | } else { |
ad5255c1 | 836 | dout("%s %llx %p seq %lld unchanged\n", __func__, |
ae00d4f3 | 837 | realm->ino, realm, realm->seq); |
963b61eb SW |
838 | } |
839 | ||
2e586641 XL |
840 | dout("done with %llx %p, rebuild_snapcs=%d, %p %p\n", realm->ino, |
841 | realm, rebuild_snapcs, p, e); | |
963b61eb | 842 | |
2e586641 XL |
843 | /* |
844 | * this will always track the uppest parent realm from which | |
845 | * we need to rebuild the snapshot contexts _downward_ in | |
846 | * hierarchy. | |
847 | */ | |
848 | if (rebuild_snapcs) | |
849 | realm_to_rebuild = realm; | |
850 | ||
851 | /* rebuild_snapcs when we reach the _end_ (root) of the trace */ | |
852 | if (realm_to_rebuild && p >= e) | |
853 | rebuild_snap_realms(realm_to_rebuild, &dirty_realms); | |
963b61eb | 854 | |
982d6011 YZ |
855 | if (!first_realm) |
856 | first_realm = realm; | |
857 | else | |
858 | ceph_put_snap_realm(mdsc, realm); | |
859 | ||
860 | if (p < e) | |
861 | goto more; | |
862 | ||
ae00d4f3 SW |
863 | /* |
864 | * queue cap snaps _after_ we've built the new snap contexts, | |
865 | * so that i_head_snapc can be set appropriately. | |
866 | */ | |
e8e1ba96 SW |
867 | while (!list_empty(&dirty_realms)) { |
868 | realm = list_first_entry(&dirty_realms, struct ceph_snap_realm, | |
869 | dirty_item); | |
3ae0bebc | 870 | list_del_init(&realm->dirty_item); |
ae00d4f3 SW |
871 | queue_realm_cap_snaps(realm); |
872 | } | |
873 | ||
982d6011 YZ |
874 | if (realm_ret) |
875 | *realm_ret = first_realm; | |
876 | else | |
877 | ceph_put_snap_realm(mdsc, first_realm); | |
878 | ||
963b61eb SW |
879 | __cleanup_empty_realms(mdsc); |
880 | return 0; | |
881 | ||
882 | bad: | |
f3fd3ea6 | 883 | err = -EIO; |
963b61eb | 884 | fail: |
982d6011 YZ |
885 | if (realm && !IS_ERR(realm)) |
886 | ceph_put_snap_realm(mdsc, realm); | |
887 | if (first_realm) | |
888 | ceph_put_snap_realm(mdsc, first_realm); | |
ad5255c1 | 889 | pr_err("%s error %d\n", __func__, err); |
a68e564a XL |
890 | |
891 | /* | |
892 | * When receiving a corrupted snap trace we don't know what | |
893 | * exactly has happened in MDS side. And we shouldn't continue | |
894 | * writing to OSD, which may corrupt the snapshot contents. | |
895 | * | |
896 | * Just try to blocklist this kclient and then this kclient | |
897 | * must be remounted to continue after the corrupted metadata | |
898 | * fixed in the MDS side. | |
899 | */ | |
900 | WRITE_ONCE(mdsc->fsc->mount_state, CEPH_MOUNT_FENCE_IO); | |
901 | ret = ceph_monc_blocklist_add(&client->monc, &client->msgr.inst.addr); | |
902 | if (ret) | |
903 | pr_err("%s failed to blocklist %s: %d\n", __func__, | |
904 | ceph_pr_addr(&client->msgr.inst.addr), ret); | |
905 | ||
906 | WARN(1, "%s: %s%sdo remount to continue%s", | |
907 | __func__, ret ? "" : ceph_pr_addr(&client->msgr.inst.addr), | |
908 | ret ? "" : " was blocklisted, ", | |
909 | err == -EIO ? " after corrupted snaptrace is fixed" : ""); | |
910 | ||
963b61eb SW |
911 | return err; |
912 | } | |
913 | ||
914 | ||
915 | /* | |
916 | * Send any cap_snaps that are queued for flush. Try to carry | |
917 | * s_mutex across multiple snap flushes to avoid locking overhead. | |
918 | * | |
919 | * Caller holds no locks. | |
920 | */ | |
921 | static void flush_snaps(struct ceph_mds_client *mdsc) | |
922 | { | |
923 | struct ceph_inode_info *ci; | |
924 | struct inode *inode; | |
925 | struct ceph_mds_session *session = NULL; | |
926 | ||
ad5255c1 | 927 | dout("%s\n", __func__); |
963b61eb SW |
928 | spin_lock(&mdsc->snap_flush_lock); |
929 | while (!list_empty(&mdsc->snap_flush_list)) { | |
930 | ci = list_first_entry(&mdsc->snap_flush_list, | |
931 | struct ceph_inode_info, i_snap_flush_item); | |
874c8ca1 | 932 | inode = &ci->netfs.inode; |
70b666c3 | 933 | ihold(inode); |
963b61eb | 934 | spin_unlock(&mdsc->snap_flush_lock); |
ed9b430c | 935 | ceph_flush_snaps(ci, &session); |
23c2c76e | 936 | iput(inode); |
963b61eb SW |
937 | spin_lock(&mdsc->snap_flush_lock); |
938 | } | |
939 | spin_unlock(&mdsc->snap_flush_lock); | |
940 | ||
7732fe16 | 941 | ceph_put_mds_session(session); |
ad5255c1 | 942 | dout("%s done\n", __func__); |
963b61eb SW |
943 | } |
944 | ||
0ba92e1c JL |
945 | /** |
946 | * ceph_change_snap_realm - change the snap_realm for an inode | |
947 | * @inode: inode to move to new snap realm | |
948 | * @realm: new realm to move inode into (may be NULL) | |
949 | * | |
950 | * Detach an inode from its old snaprealm (if any) and attach it to | |
951 | * the new snaprealm (if any). The old snap realm reference held by | |
952 | * the inode is put. If realm is non-NULL, then the caller's reference | |
953 | * to it is taken over by the inode. | |
954 | */ | |
955 | void ceph_change_snap_realm(struct inode *inode, struct ceph_snap_realm *realm) | |
956 | { | |
957 | struct ceph_inode_info *ci = ceph_inode(inode); | |
958 | struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc; | |
959 | struct ceph_snap_realm *oldrealm = ci->i_snap_realm; | |
960 | ||
961 | lockdep_assert_held(&ci->i_ceph_lock); | |
962 | ||
963 | if (oldrealm) { | |
964 | spin_lock(&oldrealm->inodes_with_caps_lock); | |
965 | list_del_init(&ci->i_snap_realm_item); | |
966 | if (oldrealm->ino == ci->i_vino.ino) | |
967 | oldrealm->inode = NULL; | |
968 | spin_unlock(&oldrealm->inodes_with_caps_lock); | |
969 | ceph_put_snap_realm(mdsc, oldrealm); | |
970 | } | |
971 | ||
972 | ci->i_snap_realm = realm; | |
973 | ||
974 | if (realm) { | |
975 | spin_lock(&realm->inodes_with_caps_lock); | |
976 | list_add(&ci->i_snap_realm_item, &realm->inodes_with_caps); | |
977 | if (realm->ino == ci->i_vino.ino) | |
978 | realm->inode = inode; | |
979 | spin_unlock(&realm->inodes_with_caps_lock); | |
980 | } | |
981 | } | |
963b61eb SW |
982 | |
983 | /* | |
984 | * Handle a snap notification from the MDS. | |
985 | * | |
986 | * This can take two basic forms: the simplest is just a snap creation | |
987 | * or deletion notification on an existing realm. This should update the | |
988 | * realm and its children. | |
989 | * | |
990 | * The more difficult case is realm creation, due to snap creation at a | |
991 | * new point in the file hierarchy, or due to a rename that moves a file or | |
992 | * directory into another realm. | |
993 | */ | |
994 | void ceph_handle_snap(struct ceph_mds_client *mdsc, | |
2600d2dd | 995 | struct ceph_mds_session *session, |
963b61eb SW |
996 | struct ceph_msg *msg) |
997 | { | |
3d14c5d2 | 998 | struct super_block *sb = mdsc->fsc->sb; |
2600d2dd | 999 | int mds = session->s_mds; |
963b61eb SW |
1000 | u64 split; |
1001 | int op; | |
1002 | int trace_len; | |
1003 | struct ceph_snap_realm *realm = NULL; | |
1004 | void *p = msg->front.iov_base; | |
1005 | void *e = p + msg->front.iov_len; | |
1006 | struct ceph_mds_snap_head *h; | |
1007 | int num_split_inos, num_split_realms; | |
1008 | __le64 *split_inos = NULL, *split_realms = NULL; | |
1009 | int i; | |
1010 | int locked_rwsem = 0; | |
a68e564a | 1011 | bool close_sessions = false; |
963b61eb | 1012 | |
963b61eb SW |
1013 | /* decode */ |
1014 | if (msg->front.iov_len < sizeof(*h)) | |
1015 | goto bad; | |
1016 | h = p; | |
1017 | op = le32_to_cpu(h->op); | |
1018 | split = le64_to_cpu(h->split); /* non-zero if we are splitting an | |
1019 | * existing realm */ | |
1020 | num_split_inos = le32_to_cpu(h->num_split_inos); | |
1021 | num_split_realms = le32_to_cpu(h->num_split_realms); | |
1022 | trace_len = le32_to_cpu(h->trace_len); | |
1023 | p += sizeof(*h); | |
1024 | ||
ad5255c1 XL |
1025 | dout("%s from mds%d op %s split %llx tracelen %d\n", __func__, |
1026 | mds, ceph_snap_op_name(op), split, trace_len); | |
963b61eb | 1027 | |
963b61eb | 1028 | mutex_lock(&session->s_mutex); |
62575e27 | 1029 | inc_session_sequence(session); |
963b61eb SW |
1030 | mutex_unlock(&session->s_mutex); |
1031 | ||
1032 | down_write(&mdsc->snap_rwsem); | |
1033 | locked_rwsem = 1; | |
1034 | ||
1035 | if (op == CEPH_SNAP_OP_SPLIT) { | |
1036 | struct ceph_mds_snap_realm *ri; | |
1037 | ||
1038 | /* | |
1039 | * A "split" breaks part of an existing realm off into | |
1040 | * a new realm. The MDS provides a list of inodes | |
1041 | * (with caps) and child realms that belong to the new | |
1042 | * child. | |
1043 | */ | |
1044 | split_inos = p; | |
1045 | p += sizeof(u64) * num_split_inos; | |
1046 | split_realms = p; | |
1047 | p += sizeof(u64) * num_split_realms; | |
1048 | ceph_decode_need(&p, e, sizeof(*ri), bad); | |
1049 | /* we will peek at realm info here, but will _not_ | |
1050 | * advance p, as the realm update will occur below in | |
1051 | * ceph_update_snap_trace. */ | |
1052 | ri = p; | |
1053 | ||
1054 | realm = ceph_lookup_snap_realm(mdsc, split); | |
963b61eb SW |
1055 | if (!realm) { |
1056 | realm = ceph_create_snap_realm(mdsc, split); | |
1057 | if (IS_ERR(realm)) | |
1058 | goto out; | |
1059 | } | |
963b61eb SW |
1060 | |
1061 | dout("splitting snap_realm %llx %p\n", realm->ino, realm); | |
1062 | for (i = 0; i < num_split_inos; i++) { | |
1063 | struct ceph_vino vino = { | |
1064 | .ino = le64_to_cpu(split_inos[i]), | |
1065 | .snap = CEPH_NOSNAP, | |
1066 | }; | |
1067 | struct inode *inode = ceph_find_inode(sb, vino); | |
1068 | struct ceph_inode_info *ci; | |
1069 | ||
1070 | if (!inode) | |
1071 | continue; | |
1072 | ci = ceph_inode(inode); | |
1073 | ||
be655596 | 1074 | spin_lock(&ci->i_ceph_lock); |
963b61eb SW |
1075 | if (!ci->i_snap_realm) |
1076 | goto skip_inode; | |
1077 | /* | |
1078 | * If this inode belongs to a realm that was | |
1079 | * created after our new realm, we experienced | |
1080 | * a race (due to another split notifications | |
1081 | * arriving from a different MDS). So skip | |
1082 | * this inode. | |
1083 | */ | |
1084 | if (ci->i_snap_realm->created > | |
1085 | le64_to_cpu(ri->created)) { | |
ad5255c1 XL |
1086 | dout(" leaving %p %llx.%llx in newer realm %llx %p\n", |
1087 | inode, ceph_vinop(inode), ci->i_snap_realm->ino, | |
963b61eb SW |
1088 | ci->i_snap_realm); |
1089 | goto skip_inode; | |
1090 | } | |
ad5255c1 XL |
1091 | dout(" will move %p %llx.%llx to split realm %llx %p\n", |
1092 | inode, ceph_vinop(inode), realm->ino, realm); | |
963b61eb | 1093 | |
ae00d4f3 | 1094 | ceph_get_snap_realm(mdsc, realm); |
0ba92e1c JL |
1095 | ceph_change_snap_realm(inode, realm); |
1096 | spin_unlock(&ci->i_ceph_lock); | |
23c2c76e | 1097 | iput(inode); |
963b61eb SW |
1098 | continue; |
1099 | ||
1100 | skip_inode: | |
be655596 | 1101 | spin_unlock(&ci->i_ceph_lock); |
23c2c76e | 1102 | iput(inode); |
963b61eb SW |
1103 | } |
1104 | ||
1105 | /* we may have taken some of the old realm's children. */ | |
1106 | for (i = 0; i < num_split_realms; i++) { | |
1107 | struct ceph_snap_realm *child = | |
982d6011 | 1108 | __lookup_snap_realm(mdsc, |
963b61eb | 1109 | le64_to_cpu(split_realms[i])); |
963b61eb SW |
1110 | if (!child) |
1111 | continue; | |
1112 | adjust_snap_realm_parent(mdsc, child, realm->ino); | |
1113 | } | |
1114 | } | |
1115 | ||
1116 | /* | |
1117 | * update using the provided snap trace. if we are deleting a | |
1118 | * snap, we can avoid queueing cap_snaps. | |
1119 | */ | |
a68e564a XL |
1120 | if (ceph_update_snap_trace(mdsc, p, e, |
1121 | op == CEPH_SNAP_OP_DESTROY, | |
1122 | NULL)) { | |
1123 | close_sessions = true; | |
1124 | goto bad; | |
1125 | } | |
963b61eb | 1126 | |
ae00d4f3 | 1127 | if (op == CEPH_SNAP_OP_SPLIT) |
963b61eb SW |
1128 | /* we took a reference when we created the realm, above */ |
1129 | ceph_put_snap_realm(mdsc, realm); | |
963b61eb SW |
1130 | |
1131 | __cleanup_empty_realms(mdsc); | |
1132 | ||
1133 | up_write(&mdsc->snap_rwsem); | |
1134 | ||
1135 | flush_snaps(mdsc); | |
1136 | return; | |
1137 | ||
1138 | bad: | |
ad5255c1 | 1139 | pr_err("%s corrupt snap message from mds%d\n", __func__, mds); |
9ec7cab1 | 1140 | ceph_msg_dump(msg); |
963b61eb SW |
1141 | out: |
1142 | if (locked_rwsem) | |
1143 | up_write(&mdsc->snap_rwsem); | |
a68e564a XL |
1144 | |
1145 | if (close_sessions) | |
1146 | ceph_mdsc_close_sessions(mdsc); | |
963b61eb SW |
1147 | return; |
1148 | } | |
75c9627e YZ |
1149 | |
1150 | struct ceph_snapid_map* ceph_get_snapid_map(struct ceph_mds_client *mdsc, | |
1151 | u64 snap) | |
1152 | { | |
1153 | struct ceph_snapid_map *sm, *exist; | |
1154 | struct rb_node **p, *parent; | |
1155 | int ret; | |
1156 | ||
1157 | exist = NULL; | |
1158 | spin_lock(&mdsc->snapid_map_lock); | |
1159 | p = &mdsc->snapid_map_tree.rb_node; | |
1160 | while (*p) { | |
1161 | exist = rb_entry(*p, struct ceph_snapid_map, node); | |
1162 | if (snap > exist->snap) { | |
1163 | p = &(*p)->rb_left; | |
1164 | } else if (snap < exist->snap) { | |
1165 | p = &(*p)->rb_right; | |
1166 | } else { | |
1167 | if (atomic_inc_return(&exist->ref) == 1) | |
1168 | list_del_init(&exist->lru); | |
1169 | break; | |
1170 | } | |
1171 | exist = NULL; | |
1172 | } | |
1173 | spin_unlock(&mdsc->snapid_map_lock); | |
1174 | if (exist) { | |
ad5255c1 XL |
1175 | dout("%s found snapid map %llx -> %x\n", __func__, |
1176 | exist->snap, exist->dev); | |
75c9627e YZ |
1177 | return exist; |
1178 | } | |
1179 | ||
1180 | sm = kmalloc(sizeof(*sm), GFP_NOFS); | |
1181 | if (!sm) | |
1182 | return NULL; | |
1183 | ||
1184 | ret = get_anon_bdev(&sm->dev); | |
1185 | if (ret < 0) { | |
1186 | kfree(sm); | |
1187 | return NULL; | |
1188 | } | |
1189 | ||
1190 | INIT_LIST_HEAD(&sm->lru); | |
1191 | atomic_set(&sm->ref, 1); | |
1192 | sm->snap = snap; | |
1193 | ||
1194 | exist = NULL; | |
1195 | parent = NULL; | |
1196 | p = &mdsc->snapid_map_tree.rb_node; | |
1197 | spin_lock(&mdsc->snapid_map_lock); | |
1198 | while (*p) { | |
1199 | parent = *p; | |
1200 | exist = rb_entry(*p, struct ceph_snapid_map, node); | |
1201 | if (snap > exist->snap) | |
1202 | p = &(*p)->rb_left; | |
1203 | else if (snap < exist->snap) | |
1204 | p = &(*p)->rb_right; | |
1205 | else | |
1206 | break; | |
1207 | exist = NULL; | |
1208 | } | |
1209 | if (exist) { | |
1210 | if (atomic_inc_return(&exist->ref) == 1) | |
1211 | list_del_init(&exist->lru); | |
1212 | } else { | |
1213 | rb_link_node(&sm->node, parent, p); | |
1214 | rb_insert_color(&sm->node, &mdsc->snapid_map_tree); | |
1215 | } | |
1216 | spin_unlock(&mdsc->snapid_map_lock); | |
1217 | if (exist) { | |
1218 | free_anon_bdev(sm->dev); | |
1219 | kfree(sm); | |
ad5255c1 XL |
1220 | dout("%s found snapid map %llx -> %x\n", __func__, |
1221 | exist->snap, exist->dev); | |
75c9627e YZ |
1222 | return exist; |
1223 | } | |
1224 | ||
ad5255c1 XL |
1225 | dout("%s create snapid map %llx -> %x\n", __func__, |
1226 | sm->snap, sm->dev); | |
75c9627e YZ |
1227 | return sm; |
1228 | } | |
1229 | ||
1230 | void ceph_put_snapid_map(struct ceph_mds_client* mdsc, | |
1231 | struct ceph_snapid_map *sm) | |
1232 | { | |
1233 | if (!sm) | |
1234 | return; | |
1235 | if (atomic_dec_and_lock(&sm->ref, &mdsc->snapid_map_lock)) { | |
1236 | if (!RB_EMPTY_NODE(&sm->node)) { | |
1237 | sm->last_used = jiffies; | |
1238 | list_add_tail(&sm->lru, &mdsc->snapid_map_lru); | |
1239 | spin_unlock(&mdsc->snapid_map_lock); | |
1240 | } else { | |
1241 | /* already cleaned up by | |
1242 | * ceph_cleanup_snapid_map() */ | |
1243 | spin_unlock(&mdsc->snapid_map_lock); | |
1244 | kfree(sm); | |
1245 | } | |
1246 | } | |
1247 | } | |
1248 | ||
1249 | void ceph_trim_snapid_map(struct ceph_mds_client *mdsc) | |
1250 | { | |
1251 | struct ceph_snapid_map *sm; | |
1252 | unsigned long now; | |
1253 | LIST_HEAD(to_free); | |
1254 | ||
1255 | spin_lock(&mdsc->snapid_map_lock); | |
1256 | now = jiffies; | |
1257 | ||
1258 | while (!list_empty(&mdsc->snapid_map_lru)) { | |
1259 | sm = list_first_entry(&mdsc->snapid_map_lru, | |
1260 | struct ceph_snapid_map, lru); | |
1261 | if (time_after(sm->last_used + CEPH_SNAPID_MAP_TIMEOUT, now)) | |
1262 | break; | |
1263 | ||
1264 | rb_erase(&sm->node, &mdsc->snapid_map_tree); | |
1265 | list_move(&sm->lru, &to_free); | |
1266 | } | |
1267 | spin_unlock(&mdsc->snapid_map_lock); | |
1268 | ||
1269 | while (!list_empty(&to_free)) { | |
1270 | sm = list_first_entry(&to_free, struct ceph_snapid_map, lru); | |
1271 | list_del(&sm->lru); | |
1272 | dout("trim snapid map %llx -> %x\n", sm->snap, sm->dev); | |
1273 | free_anon_bdev(sm->dev); | |
1274 | kfree(sm); | |
1275 | } | |
1276 | } | |
1277 | ||
1278 | void ceph_cleanup_snapid_map(struct ceph_mds_client *mdsc) | |
1279 | { | |
1280 | struct ceph_snapid_map *sm; | |
1281 | struct rb_node *p; | |
1282 | LIST_HEAD(to_free); | |
1283 | ||
1284 | spin_lock(&mdsc->snapid_map_lock); | |
1285 | while ((p = rb_first(&mdsc->snapid_map_tree))) { | |
1286 | sm = rb_entry(p, struct ceph_snapid_map, node); | |
1287 | rb_erase(p, &mdsc->snapid_map_tree); | |
1288 | RB_CLEAR_NODE(p); | |
1289 | list_move(&sm->lru, &to_free); | |
1290 | } | |
1291 | spin_unlock(&mdsc->snapid_map_lock); | |
1292 | ||
1293 | while (!list_empty(&to_free)) { | |
1294 | sm = list_first_entry(&to_free, struct ceph_snapid_map, lru); | |
1295 | list_del(&sm->lru); | |
1296 | free_anon_bdev(sm->dev); | |
1297 | if (WARN_ON_ONCE(atomic_read(&sm->ref))) { | |
1298 | pr_err("snapid map %llx -> %x still in use\n", | |
1299 | sm->snap, sm->dev); | |
1300 | } | |
c8d6ee01 | 1301 | kfree(sm); |
75c9627e YZ |
1302 | } |
1303 | } |