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