1 | // SPDX-License-Identifier: GPL-2.0 |
2 | #include <linux/ceph/ceph_debug.h> |
3 | |
4 | #include <linux/fs.h> |
5 | #include <linux/sort.h> |
6 | #include <linux/slab.h> |
7 | #include <linux/iversion.h> |
8 | #include "super.h" |
9 | #include "mds_client.h" |
10 | #include <linux/ceph/decode.h> |
11 | |
12 | /* unused map expires after 5 minutes */ |
13 | #define CEPH_SNAPID_MAP_TIMEOUT (5 * 60 * HZ) |
14 | |
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 | * |
64 | * caller must hold snap_rwsem. |
65 | */ |
66 | void ceph_get_snap_realm(struct ceph_mds_client *mdsc, |
67 | struct ceph_snap_realm *realm) |
68 | { |
69 | lockdep_assert_held(&mdsc->snap_rwsem); |
70 | |
71 | /* |
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. |
76 | */ |
77 | if (atomic_inc_not_zero(v: &realm->nref)) |
78 | return; |
79 | |
80 | spin_lock(lock: &mdsc->snap_empty_lock); |
81 | if (atomic_inc_return(v: &realm->nref) == 1) |
82 | list_del_init(entry: &realm->empty_item); |
83 | spin_unlock(lock: &mdsc->snap_empty_lock); |
84 | } |
85 | |
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(node: &new->node, parent, rb_link: p); |
105 | rb_insert_color(&new->node, root); |
106 | } |
107 | |
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 | |
119 | lockdep_assert_held_write(&mdsc->snap_rwsem); |
120 | |
121 | realm = kzalloc(size: sizeof(*realm), GFP_NOFS); |
122 | if (!realm) |
123 | return ERR_PTR(error: -ENOMEM); |
124 | |
125 | /* Do not release the global dummy snaprealm until unmouting */ |
126 | if (ino == CEPH_INO_GLOBAL_SNAPREALM) |
127 | atomic_set(v: &realm->nref, i: 2); |
128 | else |
129 | atomic_set(v: &realm->nref, i: 1); |
130 | realm->ino = ino; |
131 | INIT_LIST_HEAD(list: &realm->children); |
132 | INIT_LIST_HEAD(list: &realm->child_item); |
133 | INIT_LIST_HEAD(list: &realm->empty_item); |
134 | INIT_LIST_HEAD(list: &realm->dirty_item); |
135 | INIT_LIST_HEAD(list: &realm->rebuild_item); |
136 | INIT_LIST_HEAD(list: &realm->inodes_with_caps); |
137 | spin_lock_init(&realm->inodes_with_caps_lock); |
138 | __insert_snap_realm(root: &mdsc->snap_realms, new: realm); |
139 | mdsc->num_snap_realms++; |
140 | |
141 | dout("%s %llx %p\n" , __func__, realm->ino, realm); |
142 | return realm; |
143 | } |
144 | |
145 | /* |
146 | * lookup the realm rooted at @ino. |
147 | * |
148 | * caller must hold snap_rwsem. |
149 | */ |
150 | static struct ceph_snap_realm *__lookup_snap_realm(struct ceph_mds_client *mdsc, |
151 | u64 ino) |
152 | { |
153 | struct rb_node *n = mdsc->snap_realms.rb_node; |
154 | struct ceph_snap_realm *r; |
155 | |
156 | lockdep_assert_held(&mdsc->snap_rwsem); |
157 | |
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 { |
165 | dout("%s %llx %p\n" , __func__, r->ino, r); |
166 | return r; |
167 | } |
168 | } |
169 | return NULL; |
170 | } |
171 | |
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, realm: r); |
179 | return r; |
180 | } |
181 | |
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 | { |
191 | lockdep_assert_held_write(&mdsc->snap_rwsem); |
192 | |
193 | dout("%s %p %llx\n" , __func__, realm, realm->ino); |
194 | |
195 | rb_erase(&realm->node, &mdsc->snap_realms); |
196 | mdsc->num_snap_realms--; |
197 | |
198 | if (realm->parent) { |
199 | list_del_init(entry: &realm->child_item); |
200 | __put_snap_realm(mdsc, realm: realm->parent); |
201 | } |
202 | |
203 | kfree(objp: realm->prior_parent_snaps); |
204 | kfree(objp: realm->snaps); |
205 | ceph_put_snap_context(sc: realm->cached_context); |
206 | kfree(objp: 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 | { |
215 | lockdep_assert_held_write(&mdsc->snap_rwsem); |
216 | |
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 | */ |
221 | if (atomic_dec_and_test(v: &realm->nref)) |
222 | __destroy_snap_realm(mdsc, realm); |
223 | } |
224 | |
225 | /* |
226 | * See comments in ceph_get_snap_realm. Caller needn't hold any locks. |
227 | */ |
228 | void ceph_put_snap_realm(struct ceph_mds_client *mdsc, |
229 | struct ceph_snap_realm *realm) |
230 | { |
231 | if (!atomic_dec_and_lock(&realm->nref, &mdsc->snap_empty_lock)) |
232 | return; |
233 | |
234 | if (down_write_trylock(sem: &mdsc->snap_rwsem)) { |
235 | spin_unlock(lock: &mdsc->snap_empty_lock); |
236 | __destroy_snap_realm(mdsc, realm); |
237 | up_write(sem: &mdsc->snap_rwsem); |
238 | } else { |
239 | list_add(new: &realm->empty_item, head: &mdsc->snap_empty); |
240 | spin_unlock(lock: &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 | |
255 | lockdep_assert_held_write(&mdsc->snap_rwsem); |
256 | |
257 | spin_lock(lock: &mdsc->snap_empty_lock); |
258 | while (!list_empty(head: &mdsc->snap_empty)) { |
259 | realm = list_first_entry(&mdsc->snap_empty, |
260 | struct ceph_snap_realm, empty_item); |
261 | list_del(entry: &realm->empty_item); |
262 | spin_unlock(lock: &mdsc->snap_empty_lock); |
263 | __destroy_snap_realm(mdsc, realm); |
264 | spin_lock(lock: &mdsc->snap_empty_lock); |
265 | } |
266 | spin_unlock(lock: &mdsc->snap_empty_lock); |
267 | } |
268 | |
269 | void ceph_cleanup_global_and_empty_realms(struct ceph_mds_client *mdsc) |
270 | { |
271 | struct ceph_snap_realm *global_realm; |
272 | |
273 | down_write(sem: &mdsc->snap_rwsem); |
274 | global_realm = __lookup_snap_realm(mdsc, CEPH_INO_GLOBAL_SNAPREALM); |
275 | if (global_realm) |
276 | ceph_put_snap_realm(mdsc, realm: global_realm); |
277 | __cleanup_empty_realms(mdsc); |
278 | up_write(sem: &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 | |
295 | lockdep_assert_held_write(&mdsc->snap_rwsem); |
296 | |
297 | if (realm->parent_ino == parentino) |
298 | return 0; |
299 | |
300 | parent = ceph_lookup_snap_realm(mdsc, ino: parentino); |
301 | if (!parent) { |
302 | parent = ceph_create_snap_realm(mdsc, ino: parentino); |
303 | if (IS_ERR(ptr: parent)) |
304 | return PTR_ERR(ptr: parent); |
305 | } |
306 | dout("%s %llx %p: %llx %p -> %llx %p\n" , __func__, realm->ino, |
307 | realm, realm->parent_ino, realm->parent, parentino, parent); |
308 | if (realm->parent) { |
309 | list_del_init(entry: &realm->child_item); |
310 | ceph_put_snap_realm(mdsc, realm: realm->parent); |
311 | } |
312 | realm->parent_ino = parentino; |
313 | realm->parent = parent; |
314 | list_add(new: &realm->child_item, head: &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 | |
328 | |
329 | /* |
330 | * build the snap context for a given realm. |
331 | */ |
332 | static int build_snap_context(struct ceph_snap_realm *realm, |
333 | struct list_head *realm_queue, |
334 | struct list_head *dirty_realms) |
335 | { |
336 | struct ceph_snap_realm *parent = realm->parent; |
337 | struct ceph_snap_context *snapc; |
338 | int err = 0; |
339 | u32 num = realm->num_prior_parent_snaps + realm->num_snaps; |
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) { |
348 | /* add to the queue head */ |
349 | list_add(new: &parent->rebuild_item, head: realm_queue); |
350 | return 1; |
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 && |
360 | realm->cached_context->seq == realm->seq && |
361 | (!parent || |
362 | realm->cached_context->seq >= parent->cached_context->seq)) { |
363 | dout("%s %llx %p: %p seq %lld (%u snaps) (unchanged)\n" , |
364 | __func__, realm->ino, realm, realm->cached_context, |
365 | realm->cached_context->seq, |
366 | (unsigned int)realm->cached_context->num_snaps); |
367 | return 0; |
368 | } |
369 | |
370 | /* alloc new snap context */ |
371 | err = -ENOMEM; |
372 | if (num > (SIZE_MAX - sizeof(*snapc)) / sizeof(u64)) |
373 | goto fail; |
374 | snapc = ceph_create_snap_context(snap_count: num, GFP_NOFS); |
375 | if (!snapc) |
376 | goto fail; |
377 | |
378 | /* build (reverse sorted) snap vector */ |
379 | num = 0; |
380 | snapc->seq = realm->seq; |
381 | if (parent) { |
382 | u32 i; |
383 | |
384 | /* include any of parent's snaps occurring _after_ my |
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(base: snapc->snaps, num, size: sizeof(u64), cmp_func: cmpu64_rev, NULL); |
402 | snapc->num_snaps = num; |
403 | dout("%s %llx %p: %p seq %lld (%u snaps)\n" , __func__, realm->ino, |
404 | realm, snapc, snapc->seq, (unsigned int) snapc->num_snaps); |
405 | |
406 | ceph_put_snap_context(sc: realm->cached_context); |
407 | realm->cached_context = snapc; |
408 | /* queue realm for cap_snap creation */ |
409 | list_add_tail(new: &realm->dirty_item, head: dirty_realms); |
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(sc: realm->cached_context); |
419 | realm->cached_context = NULL; |
420 | } |
421 | pr_err("%s %llx %p fail %d\n" , __func__, realm->ino, realm, err); |
422 | return err; |
423 | } |
424 | |
425 | /* |
426 | * rebuild snap context for the given realm and all of its children. |
427 | */ |
428 | static void rebuild_snap_realms(struct ceph_snap_realm *realm, |
429 | struct list_head *dirty_realms) |
430 | { |
431 | LIST_HEAD(realm_queue); |
432 | int last = 0; |
433 | bool skip = false; |
434 | |
435 | list_add_tail(new: &realm->rebuild_item, head: &realm_queue); |
436 | |
437 | while (!list_empty(head: &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(entry: &_realm->rebuild_item); |
451 | continue; |
452 | } |
453 | |
454 | last = build_snap_context(realm: _realm, realm_queue: &realm_queue, dirty_realms); |
455 | dout("%s %llx %p, %s\n" , __func__, _realm->ino, _realm, |
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(head: &child->rebuild_item)) { |
461 | skip = true; |
462 | break; |
463 | } |
464 | } |
465 | |
466 | if (!skip) { |
467 | list_for_each_entry(child, &_realm->children, child_item) |
468 | list_add_tail(new: &child->rebuild_item, head: &realm_queue); |
469 | } |
470 | |
471 | /* last == 1 means need to build parent first */ |
472 | if (last <= 0) |
473 | list_del_init(entry: &_realm->rebuild_item); |
474 | } |
475 | } |
476 | |
477 | |
478 | /* |
479 | * helper to allocate and decode an array of snapids. free prior |
480 | * instance, if any. |
481 | */ |
482 | static int dup_array(u64 **dst, __le64 *src, u32 num) |
483 | { |
484 | u32 i; |
485 | |
486 | kfree(objp: *dst); |
487 | if (num) { |
488 | *dst = kcalloc(n: num, size: sizeof(u64), GFP_NOFS); |
489 | if (!*dst) |
490 | return -ENOMEM; |
491 | for (i = 0; i < num; i++) |
492 | (*dst)[i] = get_unaligned_le64(p: src + i); |
493 | } else { |
494 | *dst = NULL; |
495 | } |
496 | return 0; |
497 | } |
498 | |
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 | } |
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 | */ |
522 | static void ceph_queue_cap_snap(struct ceph_inode_info *ci, |
523 | struct ceph_cap_snap **pcapsnap) |
524 | { |
525 | struct inode *inode = &ci->netfs.inode; |
526 | struct ceph_snap_context *old_snapc, *new_snapc; |
527 | struct ceph_cap_snap *capsnap = *pcapsnap; |
528 | struct ceph_buffer *old_blob = NULL; |
529 | int used, dirty; |
530 | |
531 | spin_lock(lock: &ci->i_ceph_lock); |
532 | used = __ceph_caps_used(ci); |
533 | dirty = __ceph_caps_dirty(ci); |
534 | |
535 | old_snapc = ci->i_head_snapc; |
536 | new_snapc = ci->i_snap_realm->cached_context; |
537 | |
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 | |
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. */ |
551 | dout("%s %p %llx.%llx already pending\n" , |
552 | __func__, inode, ceph_vinop(inode)); |
553 | goto update_snapc; |
554 | } |
555 | if (ci->i_wrbuffer_ref_head == 0 && |
556 | !(dirty & (CEPH_CAP_ANY_EXCL|CEPH_CAP_FILE_WR))) { |
557 | dout("%s %p %llx.%llx nothing dirty|writing\n" , |
558 | __func__, inode, ceph_vinop(inode)); |
559 | goto update_snapc; |
560 | } |
561 | |
562 | BUG_ON(!old_snapc); |
563 | |
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(o: old_snapc, n: 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) { |
578 | dout("%s %p %llx.%llx no new_snap|dirty_page|writing\n" , |
579 | __func__, inode, ceph_vinop(inode)); |
580 | goto update_snapc; |
581 | } |
582 | } |
583 | |
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" ); |
587 | ihold(inode); |
588 | |
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) { |
598 | old_blob = __ceph_build_xattrs_blob(ci); |
599 | capsnap->xattr_blob = |
600 | ceph_buffer_get(b: ci->i_xattrs.blob); |
601 | capsnap->xattr_version = ci->i_xattrs.version; |
602 | } else { |
603 | capsnap->xattr_blob = NULL; |
604 | capsnap->xattr_version = 0; |
605 | } |
606 | |
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(new: &capsnap->ci_item, head: &ci->i_cap_snaps); |
616 | |
617 | if (used & CEPH_CAP_FILE_WR) { |
618 | dout("%s %p %llx.%llx cap_snap %p snapc %p seq %llu used WR," |
619 | " now pending\n" , __func__, inode, ceph_vinop(inode), |
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 | } |
626 | *pcapsnap = NULL; |
627 | old_snapc = NULL; |
628 | |
629 | update_snapc: |
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 { |
636 | ci->i_head_snapc = ceph_get_snap_context(sc: new_snapc); |
637 | dout(" new snapc is %p\n" , new_snapc); |
638 | } |
639 | spin_unlock(lock: &ci->i_ceph_lock); |
640 | |
641 | ceph_buffer_put(b: old_blob); |
642 | ceph_put_snap_context(sc: old_snapc); |
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 | * |
651 | * Caller must hold i_ceph_lock. |
652 | */ |
653 | int __ceph_finish_cap_snap(struct ceph_inode_info *ci, |
654 | struct ceph_cap_snap *capsnap) |
655 | { |
656 | struct inode *inode = &ci->netfs.inode; |
657 | struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(sb: inode->i_sb); |
658 | |
659 | BUG_ON(capsnap->writing); |
660 | capsnap->size = i_size_read(inode); |
661 | capsnap->mtime = inode_get_mtime(inode); |
662 | capsnap->atime = inode_get_atime(inode); |
663 | capsnap->ctime = inode_get_ctime(inode); |
664 | capsnap->btime = ci->i_btime; |
665 | capsnap->change_attr = inode_peek_iversion_raw(inode); |
666 | capsnap->time_warp_seq = ci->i_time_warp_seq; |
667 | capsnap->truncate_size = ci->i_truncate_size; |
668 | capsnap->truncate_seq = ci->i_truncate_seq; |
669 | if (capsnap->dirty_pages) { |
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); |
675 | return 0; |
676 | } |
677 | |
678 | /* |
679 | * Defer flushing the capsnap if the dirty buffer not flushed yet. |
680 | * And trigger to flush the buffer immediately. |
681 | */ |
682 | if (ci->i_wrbuffer_ref) { |
683 | dout("%s %p %llx.%llx cap_snap %p snapc %p %llu %s s=%llu " |
684 | "used WRBUFFER, delaying\n" , __func__, inode, |
685 | ceph_vinop(inode), capsnap, capsnap->context, |
686 | capsnap->context->seq, ceph_cap_string(capsnap->dirty), |
687 | capsnap->size); |
688 | ceph_queue_writeback(inode); |
689 | return 0; |
690 | } |
691 | |
692 | ci->i_ceph_flags |= CEPH_I_FLUSH_SNAPS; |
693 | dout("%s %p %llx.%llx cap_snap %p snapc %p %llu %s s=%llu\n" , |
694 | __func__, inode, ceph_vinop(inode), capsnap, capsnap->context, |
695 | capsnap->context->seq, ceph_cap_string(capsnap->dirty), |
696 | capsnap->size); |
697 | |
698 | spin_lock(lock: &mdsc->snap_flush_lock); |
699 | if (list_empty(head: &ci->i_snap_flush_item)) { |
700 | ihold(inode); |
701 | list_add_tail(new: &ci->i_snap_flush_item, head: &mdsc->snap_flush_list); |
702 | } |
703 | spin_unlock(lock: &mdsc->snap_flush_lock); |
704 | return 1; /* caller may want to ceph_flush_snaps */ |
705 | } |
706 | |
707 | /* |
708 | * Queue cap_snaps for snap writeback for this realm and its children. |
709 | * Called under snap_rwsem, so realm topology won't change. |
710 | */ |
711 | static void queue_realm_cap_snaps(struct ceph_snap_realm *realm) |
712 | { |
713 | struct ceph_inode_info *ci; |
714 | struct inode *lastinode = NULL; |
715 | struct ceph_cap_snap *capsnap = NULL; |
716 | |
717 | dout("%s %p %llx inode\n" , __func__, realm, realm->ino); |
718 | |
719 | spin_lock(lock: &realm->inodes_with_caps_lock); |
720 | list_for_each_entry(ci, &realm->inodes_with_caps, i_snap_realm_item) { |
721 | struct inode *inode = igrab(&ci->netfs.inode); |
722 | if (!inode) |
723 | continue; |
724 | spin_unlock(lock: &realm->inodes_with_caps_lock); |
725 | iput(lastinode); |
726 | lastinode = inode; |
727 | |
728 | /* |
729 | * Allocate the capsnap memory outside of ceph_queue_cap_snap() |
730 | * to reduce very possible but unnecessary frequently memory |
731 | * allocate/free in this loop. |
732 | */ |
733 | if (!capsnap) { |
734 | capsnap = kmem_cache_zalloc(k: ceph_cap_snap_cachep, GFP_NOFS); |
735 | if (!capsnap) { |
736 | pr_err("ENOMEM allocating ceph_cap_snap on %p\n" , |
737 | inode); |
738 | return; |
739 | } |
740 | } |
741 | capsnap->cap_flush.is_capsnap = true; |
742 | refcount_set(r: &capsnap->nref, n: 1); |
743 | INIT_LIST_HEAD(list: &capsnap->cap_flush.i_list); |
744 | INIT_LIST_HEAD(list: &capsnap->cap_flush.g_list); |
745 | INIT_LIST_HEAD(list: &capsnap->ci_item); |
746 | |
747 | ceph_queue_cap_snap(ci, pcapsnap: &capsnap); |
748 | spin_lock(lock: &realm->inodes_with_caps_lock); |
749 | } |
750 | spin_unlock(lock: &realm->inodes_with_caps_lock); |
751 | iput(lastinode); |
752 | |
753 | if (capsnap) |
754 | kmem_cache_free(s: ceph_cap_snap_cachep, objp: capsnap); |
755 | dout("%s %p %llx done\n" , __func__, realm, realm->ino); |
756 | } |
757 | |
758 | /* |
759 | * Parse and apply a snapblob "snap trace" from the MDS. This specifies |
760 | * the snap realm parameters from a given realm and all of its ancestors, |
761 | * up to the root. |
762 | * |
763 | * Caller must hold snap_rwsem for write. |
764 | */ |
765 | int ceph_update_snap_trace(struct ceph_mds_client *mdsc, |
766 | void *p, void *e, bool deletion, |
767 | struct ceph_snap_realm **realm_ret) |
768 | { |
769 | struct ceph_mds_snap_realm *ri; /* encoded */ |
770 | __le64 *snaps; /* encoded */ |
771 | __le64 *prior_parent_snaps; /* encoded */ |
772 | struct ceph_snap_realm *realm; |
773 | struct ceph_snap_realm *first_realm = NULL; |
774 | struct ceph_snap_realm *realm_to_rebuild = NULL; |
775 | struct ceph_client *client = mdsc->fsc->client; |
776 | int rebuild_snapcs; |
777 | int err = -ENOMEM; |
778 | int ret; |
779 | LIST_HEAD(dirty_realms); |
780 | |
781 | lockdep_assert_held_write(&mdsc->snap_rwsem); |
782 | |
783 | dout("%s deletion=%d\n" , __func__, deletion); |
784 | more: |
785 | realm = NULL; |
786 | rebuild_snapcs = 0; |
787 | ceph_decode_need(&p, e, sizeof(*ri), bad); |
788 | ri = p; |
789 | p += sizeof(*ri); |
790 | ceph_decode_need(&p, e, sizeof(u64)*(le32_to_cpu(ri->num_snaps) + |
791 | le32_to_cpu(ri->num_prior_parent_snaps)), bad); |
792 | snaps = p; |
793 | p += sizeof(u64) * le32_to_cpu(ri->num_snaps); |
794 | prior_parent_snaps = p; |
795 | p += sizeof(u64) * le32_to_cpu(ri->num_prior_parent_snaps); |
796 | |
797 | realm = ceph_lookup_snap_realm(mdsc, le64_to_cpu(ri->ino)); |
798 | if (!realm) { |
799 | realm = ceph_create_snap_realm(mdsc, le64_to_cpu(ri->ino)); |
800 | if (IS_ERR(ptr: realm)) { |
801 | err = PTR_ERR(ptr: realm); |
802 | goto fail; |
803 | } |
804 | } |
805 | |
806 | /* ensure the parent is correct */ |
807 | err = adjust_snap_realm_parent(mdsc, realm, le64_to_cpu(ri->parent)); |
808 | if (err < 0) |
809 | goto fail; |
810 | rebuild_snapcs += err; |
811 | |
812 | if (le64_to_cpu(ri->seq) > realm->seq) { |
813 | dout("%s updating %llx %p %lld -> %lld\n" , __func__, |
814 | realm->ino, realm, realm->seq, le64_to_cpu(ri->seq)); |
815 | /* update realm parameters, snap lists */ |
816 | realm->seq = le64_to_cpu(ri->seq); |
817 | realm->created = le64_to_cpu(ri->created); |
818 | realm->parent_since = le64_to_cpu(ri->parent_since); |
819 | |
820 | realm->num_snaps = le32_to_cpu(ri->num_snaps); |
821 | err = dup_array(dst: &realm->snaps, src: snaps, num: realm->num_snaps); |
822 | if (err < 0) |
823 | goto fail; |
824 | |
825 | realm->num_prior_parent_snaps = |
826 | le32_to_cpu(ri->num_prior_parent_snaps); |
827 | err = dup_array(dst: &realm->prior_parent_snaps, src: prior_parent_snaps, |
828 | num: realm->num_prior_parent_snaps); |
829 | if (err < 0) |
830 | goto fail; |
831 | |
832 | if (realm->seq > mdsc->last_snap_seq) |
833 | mdsc->last_snap_seq = realm->seq; |
834 | |
835 | rebuild_snapcs = 1; |
836 | } else if (!realm->cached_context) { |
837 | dout("%s %llx %p seq %lld new\n" , __func__, |
838 | realm->ino, realm, realm->seq); |
839 | rebuild_snapcs = 1; |
840 | } else { |
841 | dout("%s %llx %p seq %lld unchanged\n" , __func__, |
842 | realm->ino, realm, realm->seq); |
843 | } |
844 | |
845 | dout("done with %llx %p, rebuild_snapcs=%d, %p %p\n" , realm->ino, |
846 | realm, rebuild_snapcs, p, e); |
847 | |
848 | /* |
849 | * this will always track the uppest parent realm from which |
850 | * we need to rebuild the snapshot contexts _downward_ in |
851 | * hierarchy. |
852 | */ |
853 | if (rebuild_snapcs) |
854 | realm_to_rebuild = realm; |
855 | |
856 | /* rebuild_snapcs when we reach the _end_ (root) of the trace */ |
857 | if (realm_to_rebuild && p >= e) |
858 | rebuild_snap_realms(realm: realm_to_rebuild, dirty_realms: &dirty_realms); |
859 | |
860 | if (!first_realm) |
861 | first_realm = realm; |
862 | else |
863 | ceph_put_snap_realm(mdsc, realm); |
864 | |
865 | if (p < e) |
866 | goto more; |
867 | |
868 | /* |
869 | * queue cap snaps _after_ we've built the new snap contexts, |
870 | * so that i_head_snapc can be set appropriately. |
871 | */ |
872 | while (!list_empty(head: &dirty_realms)) { |
873 | realm = list_first_entry(&dirty_realms, struct ceph_snap_realm, |
874 | dirty_item); |
875 | list_del_init(entry: &realm->dirty_item); |
876 | queue_realm_cap_snaps(realm); |
877 | } |
878 | |
879 | if (realm_ret) |
880 | *realm_ret = first_realm; |
881 | else |
882 | ceph_put_snap_realm(mdsc, realm: first_realm); |
883 | |
884 | __cleanup_empty_realms(mdsc); |
885 | return 0; |
886 | |
887 | bad: |
888 | err = -EIO; |
889 | fail: |
890 | if (realm && !IS_ERR(ptr: realm)) |
891 | ceph_put_snap_realm(mdsc, realm); |
892 | if (first_realm) |
893 | ceph_put_snap_realm(mdsc, realm: first_realm); |
894 | pr_err("%s error %d\n" , __func__, err); |
895 | |
896 | /* |
897 | * When receiving a corrupted snap trace we don't know what |
898 | * exactly has happened in MDS side. And we shouldn't continue |
899 | * writing to OSD, which may corrupt the snapshot contents. |
900 | * |
901 | * Just try to blocklist this kclient and then this kclient |
902 | * must be remounted to continue after the corrupted metadata |
903 | * fixed in the MDS side. |
904 | */ |
905 | WRITE_ONCE(mdsc->fsc->mount_state, CEPH_MOUNT_FENCE_IO); |
906 | ret = ceph_monc_blocklist_add(monc: &client->monc, client_addr: &client->msgr.inst.addr); |
907 | if (ret) |
908 | pr_err("%s failed to blocklist %s: %d\n" , __func__, |
909 | ceph_pr_addr(&client->msgr.inst.addr), ret); |
910 | |
911 | WARN(1, "%s: %s%sdo remount to continue%s" , |
912 | __func__, ret ? "" : ceph_pr_addr(&client->msgr.inst.addr), |
913 | ret ? "" : " was blocklisted, " , |
914 | err == -EIO ? " after corrupted snaptrace is fixed" : "" ); |
915 | |
916 | return err; |
917 | } |
918 | |
919 | |
920 | /* |
921 | * Send any cap_snaps that are queued for flush. Try to carry |
922 | * s_mutex across multiple snap flushes to avoid locking overhead. |
923 | * |
924 | * Caller holds no locks. |
925 | */ |
926 | static void flush_snaps(struct ceph_mds_client *mdsc) |
927 | { |
928 | struct ceph_inode_info *ci; |
929 | struct inode *inode; |
930 | struct ceph_mds_session *session = NULL; |
931 | |
932 | dout("%s\n" , __func__); |
933 | spin_lock(lock: &mdsc->snap_flush_lock); |
934 | while (!list_empty(head: &mdsc->snap_flush_list)) { |
935 | ci = list_first_entry(&mdsc->snap_flush_list, |
936 | struct ceph_inode_info, i_snap_flush_item); |
937 | inode = &ci->netfs.inode; |
938 | ihold(inode); |
939 | spin_unlock(lock: &mdsc->snap_flush_lock); |
940 | ceph_flush_snaps(ci, psession: &session); |
941 | iput(inode); |
942 | spin_lock(lock: &mdsc->snap_flush_lock); |
943 | } |
944 | spin_unlock(lock: &mdsc->snap_flush_lock); |
945 | |
946 | ceph_put_mds_session(s: session); |
947 | dout("%s done\n" , __func__); |
948 | } |
949 | |
950 | /** |
951 | * ceph_change_snap_realm - change the snap_realm for an inode |
952 | * @inode: inode to move to new snap realm |
953 | * @realm: new realm to move inode into (may be NULL) |
954 | * |
955 | * Detach an inode from its old snaprealm (if any) and attach it to |
956 | * the new snaprealm (if any). The old snap realm reference held by |
957 | * the inode is put. If realm is non-NULL, then the caller's reference |
958 | * to it is taken over by the inode. |
959 | */ |
960 | void ceph_change_snap_realm(struct inode *inode, struct ceph_snap_realm *realm) |
961 | { |
962 | struct ceph_inode_info *ci = ceph_inode(inode); |
963 | struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc; |
964 | struct ceph_snap_realm *oldrealm = ci->i_snap_realm; |
965 | |
966 | lockdep_assert_held(&ci->i_ceph_lock); |
967 | |
968 | if (oldrealm) { |
969 | spin_lock(lock: &oldrealm->inodes_with_caps_lock); |
970 | list_del_init(entry: &ci->i_snap_realm_item); |
971 | if (oldrealm->ino == ci->i_vino.ino) |
972 | oldrealm->inode = NULL; |
973 | spin_unlock(lock: &oldrealm->inodes_with_caps_lock); |
974 | ceph_put_snap_realm(mdsc, realm: oldrealm); |
975 | } |
976 | |
977 | ci->i_snap_realm = realm; |
978 | |
979 | if (realm) { |
980 | spin_lock(lock: &realm->inodes_with_caps_lock); |
981 | list_add(new: &ci->i_snap_realm_item, head: &realm->inodes_with_caps); |
982 | if (realm->ino == ci->i_vino.ino) |
983 | realm->inode = inode; |
984 | spin_unlock(lock: &realm->inodes_with_caps_lock); |
985 | } |
986 | } |
987 | |
988 | /* |
989 | * Handle a snap notification from the MDS. |
990 | * |
991 | * This can take two basic forms: the simplest is just a snap creation |
992 | * or deletion notification on an existing realm. This should update the |
993 | * realm and its children. |
994 | * |
995 | * The more difficult case is realm creation, due to snap creation at a |
996 | * new point in the file hierarchy, or due to a rename that moves a file or |
997 | * directory into another realm. |
998 | */ |
999 | void ceph_handle_snap(struct ceph_mds_client *mdsc, |
1000 | struct ceph_mds_session *session, |
1001 | struct ceph_msg *msg) |
1002 | { |
1003 | struct super_block *sb = mdsc->fsc->sb; |
1004 | int mds = session->s_mds; |
1005 | u64 split; |
1006 | int op; |
1007 | int trace_len; |
1008 | struct ceph_snap_realm *realm = NULL; |
1009 | void *p = msg->front.iov_base; |
1010 | void *e = p + msg->front.iov_len; |
1011 | struct ceph_mds_snap_head *h; |
1012 | int num_split_inos, num_split_realms; |
1013 | __le64 *split_inos = NULL, *split_realms = NULL; |
1014 | int i; |
1015 | int locked_rwsem = 0; |
1016 | bool close_sessions = false; |
1017 | |
1018 | if (!ceph_inc_mds_stopping_blocker(mdsc, session)) |
1019 | return; |
1020 | |
1021 | /* decode */ |
1022 | if (msg->front.iov_len < sizeof(*h)) |
1023 | goto bad; |
1024 | h = p; |
1025 | op = le32_to_cpu(h->op); |
1026 | split = le64_to_cpu(h->split); /* non-zero if we are splitting an |
1027 | * existing realm */ |
1028 | num_split_inos = le32_to_cpu(h->num_split_inos); |
1029 | num_split_realms = le32_to_cpu(h->num_split_realms); |
1030 | trace_len = le32_to_cpu(h->trace_len); |
1031 | p += sizeof(*h); |
1032 | |
1033 | dout("%s from mds%d op %s split %llx tracelen %d\n" , __func__, |
1034 | mds, ceph_snap_op_name(op), split, trace_len); |
1035 | |
1036 | down_write(sem: &mdsc->snap_rwsem); |
1037 | locked_rwsem = 1; |
1038 | |
1039 | if (op == CEPH_SNAP_OP_SPLIT) { |
1040 | struct ceph_mds_snap_realm *ri; |
1041 | |
1042 | /* |
1043 | * A "split" breaks part of an existing realm off into |
1044 | * a new realm. The MDS provides a list of inodes |
1045 | * (with caps) and child realms that belong to the new |
1046 | * child. |
1047 | */ |
1048 | split_inos = p; |
1049 | p += sizeof(u64) * num_split_inos; |
1050 | split_realms = p; |
1051 | p += sizeof(u64) * num_split_realms; |
1052 | ceph_decode_need(&p, e, sizeof(*ri), bad); |
1053 | /* we will peek at realm info here, but will _not_ |
1054 | * advance p, as the realm update will occur below in |
1055 | * ceph_update_snap_trace. */ |
1056 | ri = p; |
1057 | |
1058 | realm = ceph_lookup_snap_realm(mdsc, ino: split); |
1059 | if (!realm) { |
1060 | realm = ceph_create_snap_realm(mdsc, ino: split); |
1061 | if (IS_ERR(ptr: realm)) |
1062 | goto out; |
1063 | } |
1064 | |
1065 | dout("splitting snap_realm %llx %p\n" , realm->ino, realm); |
1066 | for (i = 0; i < num_split_inos; i++) { |
1067 | struct ceph_vino vino = { |
1068 | .ino = le64_to_cpu(split_inos[i]), |
1069 | .snap = CEPH_NOSNAP, |
1070 | }; |
1071 | struct inode *inode = ceph_find_inode(sb, vino); |
1072 | struct ceph_inode_info *ci; |
1073 | |
1074 | if (!inode) |
1075 | continue; |
1076 | ci = ceph_inode(inode); |
1077 | |
1078 | spin_lock(lock: &ci->i_ceph_lock); |
1079 | if (!ci->i_snap_realm) |
1080 | goto skip_inode; |
1081 | /* |
1082 | * If this inode belongs to a realm that was |
1083 | * created after our new realm, we experienced |
1084 | * a race (due to another split notifications |
1085 | * arriving from a different MDS). So skip |
1086 | * this inode. |
1087 | */ |
1088 | if (ci->i_snap_realm->created > |
1089 | le64_to_cpu(ri->created)) { |
1090 | dout(" leaving %p %llx.%llx in newer realm %llx %p\n" , |
1091 | inode, ceph_vinop(inode), ci->i_snap_realm->ino, |
1092 | ci->i_snap_realm); |
1093 | goto skip_inode; |
1094 | } |
1095 | dout(" will move %p %llx.%llx to split realm %llx %p\n" , |
1096 | inode, ceph_vinop(inode), realm->ino, realm); |
1097 | |
1098 | ceph_get_snap_realm(mdsc, realm); |
1099 | ceph_change_snap_realm(inode, realm); |
1100 | spin_unlock(lock: &ci->i_ceph_lock); |
1101 | iput(inode); |
1102 | continue; |
1103 | |
1104 | skip_inode: |
1105 | spin_unlock(lock: &ci->i_ceph_lock); |
1106 | iput(inode); |
1107 | } |
1108 | |
1109 | /* we may have taken some of the old realm's children. */ |
1110 | for (i = 0; i < num_split_realms; i++) { |
1111 | struct ceph_snap_realm *child = |
1112 | __lookup_snap_realm(mdsc, |
1113 | le64_to_cpu(split_realms[i])); |
1114 | if (!child) |
1115 | continue; |
1116 | adjust_snap_realm_parent(mdsc, realm: child, parentino: realm->ino); |
1117 | } |
1118 | } else { |
1119 | /* |
1120 | * In the non-split case both 'num_split_inos' and |
1121 | * 'num_split_realms' should be 0, making this a no-op. |
1122 | * However the MDS happens to populate 'split_realms' list |
1123 | * in one of the UPDATE op cases by mistake. |
1124 | * |
1125 | * Skip both lists just in case to ensure that 'p' is |
1126 | * positioned at the start of realm info, as expected by |
1127 | * ceph_update_snap_trace(). |
1128 | */ |
1129 | p += sizeof(u64) * num_split_inos; |
1130 | p += sizeof(u64) * num_split_realms; |
1131 | } |
1132 | |
1133 | /* |
1134 | * update using the provided snap trace. if we are deleting a |
1135 | * snap, we can avoid queueing cap_snaps. |
1136 | */ |
1137 | if (ceph_update_snap_trace(mdsc, p, e, |
1138 | deletion: op == CEPH_SNAP_OP_DESTROY, |
1139 | NULL)) { |
1140 | close_sessions = true; |
1141 | goto bad; |
1142 | } |
1143 | |
1144 | if (op == CEPH_SNAP_OP_SPLIT) |
1145 | /* we took a reference when we created the realm, above */ |
1146 | ceph_put_snap_realm(mdsc, realm); |
1147 | |
1148 | __cleanup_empty_realms(mdsc); |
1149 | |
1150 | up_write(sem: &mdsc->snap_rwsem); |
1151 | |
1152 | flush_snaps(mdsc); |
1153 | ceph_dec_mds_stopping_blocker(mdsc); |
1154 | return; |
1155 | |
1156 | bad: |
1157 | pr_err("%s corrupt snap message from mds%d\n" , __func__, mds); |
1158 | ceph_msg_dump(msg); |
1159 | out: |
1160 | if (locked_rwsem) |
1161 | up_write(sem: &mdsc->snap_rwsem); |
1162 | |
1163 | ceph_dec_mds_stopping_blocker(mdsc); |
1164 | |
1165 | if (close_sessions) |
1166 | ceph_mdsc_close_sessions(mdsc); |
1167 | return; |
1168 | } |
1169 | |
1170 | struct ceph_snapid_map* ceph_get_snapid_map(struct ceph_mds_client *mdsc, |
1171 | u64 snap) |
1172 | { |
1173 | struct ceph_snapid_map *sm, *exist; |
1174 | struct rb_node **p, *parent; |
1175 | int ret; |
1176 | |
1177 | exist = NULL; |
1178 | spin_lock(lock: &mdsc->snapid_map_lock); |
1179 | p = &mdsc->snapid_map_tree.rb_node; |
1180 | while (*p) { |
1181 | exist = rb_entry(*p, struct ceph_snapid_map, node); |
1182 | if (snap > exist->snap) { |
1183 | p = &(*p)->rb_left; |
1184 | } else if (snap < exist->snap) { |
1185 | p = &(*p)->rb_right; |
1186 | } else { |
1187 | if (atomic_inc_return(v: &exist->ref) == 1) |
1188 | list_del_init(entry: &exist->lru); |
1189 | break; |
1190 | } |
1191 | exist = NULL; |
1192 | } |
1193 | spin_unlock(lock: &mdsc->snapid_map_lock); |
1194 | if (exist) { |
1195 | dout("%s found snapid map %llx -> %x\n" , __func__, |
1196 | exist->snap, exist->dev); |
1197 | return exist; |
1198 | } |
1199 | |
1200 | sm = kmalloc(size: sizeof(*sm), GFP_NOFS); |
1201 | if (!sm) |
1202 | return NULL; |
1203 | |
1204 | ret = get_anon_bdev(&sm->dev); |
1205 | if (ret < 0) { |
1206 | kfree(objp: sm); |
1207 | return NULL; |
1208 | } |
1209 | |
1210 | INIT_LIST_HEAD(list: &sm->lru); |
1211 | atomic_set(v: &sm->ref, i: 1); |
1212 | sm->snap = snap; |
1213 | |
1214 | exist = NULL; |
1215 | parent = NULL; |
1216 | p = &mdsc->snapid_map_tree.rb_node; |
1217 | spin_lock(lock: &mdsc->snapid_map_lock); |
1218 | while (*p) { |
1219 | parent = *p; |
1220 | exist = rb_entry(*p, struct ceph_snapid_map, node); |
1221 | if (snap > exist->snap) |
1222 | p = &(*p)->rb_left; |
1223 | else if (snap < exist->snap) |
1224 | p = &(*p)->rb_right; |
1225 | else |
1226 | break; |
1227 | exist = NULL; |
1228 | } |
1229 | if (exist) { |
1230 | if (atomic_inc_return(v: &exist->ref) == 1) |
1231 | list_del_init(entry: &exist->lru); |
1232 | } else { |
1233 | rb_link_node(node: &sm->node, parent, rb_link: p); |
1234 | rb_insert_color(&sm->node, &mdsc->snapid_map_tree); |
1235 | } |
1236 | spin_unlock(lock: &mdsc->snapid_map_lock); |
1237 | if (exist) { |
1238 | free_anon_bdev(sm->dev); |
1239 | kfree(objp: sm); |
1240 | dout("%s found snapid map %llx -> %x\n" , __func__, |
1241 | exist->snap, exist->dev); |
1242 | return exist; |
1243 | } |
1244 | |
1245 | dout("%s create snapid map %llx -> %x\n" , __func__, |
1246 | sm->snap, sm->dev); |
1247 | return sm; |
1248 | } |
1249 | |
1250 | void ceph_put_snapid_map(struct ceph_mds_client* mdsc, |
1251 | struct ceph_snapid_map *sm) |
1252 | { |
1253 | if (!sm) |
1254 | return; |
1255 | if (atomic_dec_and_lock(&sm->ref, &mdsc->snapid_map_lock)) { |
1256 | if (!RB_EMPTY_NODE(&sm->node)) { |
1257 | sm->last_used = jiffies; |
1258 | list_add_tail(new: &sm->lru, head: &mdsc->snapid_map_lru); |
1259 | spin_unlock(lock: &mdsc->snapid_map_lock); |
1260 | } else { |
1261 | /* already cleaned up by |
1262 | * ceph_cleanup_snapid_map() */ |
1263 | spin_unlock(lock: &mdsc->snapid_map_lock); |
1264 | kfree(objp: sm); |
1265 | } |
1266 | } |
1267 | } |
1268 | |
1269 | void ceph_trim_snapid_map(struct ceph_mds_client *mdsc) |
1270 | { |
1271 | struct ceph_snapid_map *sm; |
1272 | unsigned long now; |
1273 | LIST_HEAD(to_free); |
1274 | |
1275 | spin_lock(lock: &mdsc->snapid_map_lock); |
1276 | now = jiffies; |
1277 | |
1278 | while (!list_empty(head: &mdsc->snapid_map_lru)) { |
1279 | sm = list_first_entry(&mdsc->snapid_map_lru, |
1280 | struct ceph_snapid_map, lru); |
1281 | if (time_after(sm->last_used + CEPH_SNAPID_MAP_TIMEOUT, now)) |
1282 | break; |
1283 | |
1284 | rb_erase(&sm->node, &mdsc->snapid_map_tree); |
1285 | list_move(list: &sm->lru, head: &to_free); |
1286 | } |
1287 | spin_unlock(lock: &mdsc->snapid_map_lock); |
1288 | |
1289 | while (!list_empty(head: &to_free)) { |
1290 | sm = list_first_entry(&to_free, struct ceph_snapid_map, lru); |
1291 | list_del(entry: &sm->lru); |
1292 | dout("trim snapid map %llx -> %x\n" , sm->snap, sm->dev); |
1293 | free_anon_bdev(sm->dev); |
1294 | kfree(objp: sm); |
1295 | } |
1296 | } |
1297 | |
1298 | void ceph_cleanup_snapid_map(struct ceph_mds_client *mdsc) |
1299 | { |
1300 | struct ceph_snapid_map *sm; |
1301 | struct rb_node *p; |
1302 | LIST_HEAD(to_free); |
1303 | |
1304 | spin_lock(lock: &mdsc->snapid_map_lock); |
1305 | while ((p = rb_first(&mdsc->snapid_map_tree))) { |
1306 | sm = rb_entry(p, struct ceph_snapid_map, node); |
1307 | rb_erase(p, &mdsc->snapid_map_tree); |
1308 | RB_CLEAR_NODE(p); |
1309 | list_move(list: &sm->lru, head: &to_free); |
1310 | } |
1311 | spin_unlock(lock: &mdsc->snapid_map_lock); |
1312 | |
1313 | while (!list_empty(head: &to_free)) { |
1314 | sm = list_first_entry(&to_free, struct ceph_snapid_map, lru); |
1315 | list_del(entry: &sm->lru); |
1316 | free_anon_bdev(sm->dev); |
1317 | if (WARN_ON_ONCE(atomic_read(&sm->ref))) { |
1318 | pr_err("snapid map %llx -> %x still in use\n" , |
1319 | sm->snap, sm->dev); |
1320 | } |
1321 | kfree(objp: sm); |
1322 | } |
1323 | } |
1324 | |