]>
git.proxmox.com Git - ceph.git/blob - ceph/src/mds/SnapRealm.cc
1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
4 * Ceph - scalable distributed file system
6 * Copyright (C) 2004-2006 Sage Weil <sage@newdream.net>
8 * This is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License version 2.1, as published by the Free Software
11 * Foundation. See file COPYING.
15 #include "SnapRealm.h"
19 #include "messages/MClientSnap.h"
26 #define dout_context g_ceph_context
27 #define dout_subsys ceph_subsys_mds
29 #define dout_prefix _prefix(_dout, mdcache->mds->get_nodeid(), inode, srnode.seq, this)
30 static ostream
& _prefix(std::ostream
*_dout
, int whoami
, const CInode
*inode
,
31 uint64_t seq
, const SnapRealm
*realm
) {
32 return *_dout
<< " mds." << whoami
33 << ".cache.snaprealm(" << inode
->ino()
34 << " seq " << seq
<< " " << realm
<< ") ";
37 ostream
& operator<<(ostream
& out
, const SnapRealm
& realm
)
39 out
<< "snaprealm(" << realm
.inode
->ino()
40 << " seq " << realm
.srnode
.seq
41 << " lc " << realm
.srnode
.last_created
42 << " cr " << realm
.srnode
.created
;
43 if (realm
.srnode
.created
!= realm
.srnode
.current_parent_since
)
44 out
<< " cps " << realm
.srnode
.current_parent_since
;
45 out
<< " snaps=" << realm
.srnode
.snaps
;
46 if (realm
.srnode
.past_parents
.size()) {
47 out
<< " past_parents=(";
48 for (map
<snapid_t
, snaplink_t
>::const_iterator p
= realm
.srnode
.past_parents
.begin();
49 p
!= realm
.srnode
.past_parents
.end();
51 if (p
!= realm
.srnode
.past_parents
.begin()) out
<< ",";
52 out
<< p
->second
.first
<< "-" << p
->first
53 << "=" << p
->second
.ino
;
57 out
<< " " << &realm
<< ")";
62 void SnapRealm::add_open_past_parent(SnapRealm
*parent
, snapid_t last
)
64 auto p
= open_past_parents
.find(parent
->inode
->ino());
65 if (p
!= open_past_parents
.end()) {
66 assert(p
->second
.second
.count(last
) == 0);
67 p
->second
.second
.insert(last
);
69 open_past_parents
[parent
->inode
->ino()].first
= parent
;
70 open_past_parents
[parent
->inode
->ino()].second
.insert(last
);
71 parent
->open_past_children
.insert(this);
72 parent
->inode
->get(CInode::PIN_PASTSNAPPARENT
);
74 ++num_open_past_parents
;
77 void SnapRealm::remove_open_past_parent(inodeno_t ino
, snapid_t last
)
79 auto p
= open_past_parents
.find(ino
);
80 assert(p
!= open_past_parents
.end());
81 auto q
= p
->second
.second
.find(last
);
82 assert(q
!= p
->second
.second
.end());
83 p
->second
.second
.erase(q
);
84 --num_open_past_parents
;
85 if (p
->second
.second
.empty()) {
86 SnapRealm
*parent
= p
->second
.first
;
87 open_past_parents
.erase(p
);
88 parent
->open_past_children
.erase(this);
89 parent
->inode
->put(CInode::PIN_PASTSNAPPARENT
);
93 struct C_SR_RetryOpenParents
: public MDSInternalContextBase
{
95 snapid_t first
, last
, parent_last
;
97 MDSInternalContextBase
* fin
;
98 C_SR_RetryOpenParents(SnapRealm
*s
, snapid_t f
, snapid_t l
, snapid_t pl
,
99 inodeno_t p
, MDSInternalContextBase
*c
) :
100 sr(s
), first(f
), last(l
), parent_last(pl
), parent(p
), fin(c
) {
101 sr
->inode
->get(CInode::PIN_OPENINGSNAPPARENTS
);
103 MDSRank
*get_mds() override
{ return sr
->mdcache
->mds
; }
104 void finish(int r
) override
{
106 sr
->_remove_missing_parent(parent_last
, parent
, r
);
107 if (sr
->_open_parents(fin
, first
, last
))
109 sr
->inode
->put(CInode::PIN_OPENINGSNAPPARENTS
);
113 void SnapRealm::_remove_missing_parent(snapid_t snapid
, inodeno_t parent
, int err
)
115 map
<snapid_t
, snaplink_t
>::iterator p
= srnode
.past_parents
.find(snapid
);
116 if (p
!= srnode
.past_parents
.end()) {
117 dout(10) << __func__
<< " " << parent
<< " [" << p
->second
.first
<< ","
118 << p
->first
<< "] errno " << err
<< dendl
;
119 srnode
.past_parents
.erase(p
);
121 dout(10) << __func__
<< " " << parent
<< " not found" << dendl
;
125 bool SnapRealm::_open_parents(MDSInternalContextBase
*finish
, snapid_t first
, snapid_t last
)
127 dout(10) << "open_parents [" << first
<< "," << last
<< "]" << dendl
;
131 // make sure my current parents' parents are open...
133 dout(10) << " current parent [" << srnode
.current_parent_since
<< ",head] is " << *parent
134 << " on " << *parent
->inode
<< dendl
;
135 if (last
>= srnode
.current_parent_since
&&
136 !parent
->_open_parents(finish
, MAX(first
, srnode
.current_parent_since
), last
))
140 // and my past parents too!
141 assert(srnode
.past_parents
.size() >= num_open_past_parents
);
142 if (srnode
.past_parents
.size() > num_open_past_parents
) {
143 for (map
<snapid_t
, snaplink_t
>::iterator p
= srnode
.past_parents
.begin();
144 p
!= srnode
.past_parents
.end(); ) {
145 dout(10) << " past_parent [" << p
->second
.first
<< "," << p
->first
<< "] is "
146 << p
->second
.ino
<< dendl
;
147 CInode
*parent
= mdcache
->get_inode(p
->second
.ino
);
149 C_SR_RetryOpenParents
*fin
= new C_SR_RetryOpenParents(this, first
, last
, p
->first
,
150 p
->second
.ino
, finish
);
151 mdcache
->open_ino(p
->second
.ino
, mdcache
->mds
->mdsmap
->get_metadata_pool(), fin
);
154 if (parent
->state_test(CInode::STATE_PURGING
)) {
155 dout(10) << " skip purging past_parent " << *parent
<< dendl
;
156 srnode
.past_parents
.erase(p
++);
159 assert(parent
->snaprealm
); // hmm!
160 if (!parent
->snaprealm
->_open_parents(finish
, p
->second
.first
, p
->first
))
162 auto q
= open_past_parents
.find(p
->second
.ino
);
163 if (q
== open_past_parents
.end() ||
164 q
->second
.second
.count(p
->first
) == 0) {
165 add_open_past_parent(parent
->snaprealm
, p
->first
);
175 bool SnapRealm::open_parents(MDSInternalContextBase
*retryorfinish
) {
176 if (!_open_parents(retryorfinish
))
178 delete retryorfinish
;
182 bool SnapRealm::have_past_parents_open(snapid_t first
, snapid_t last
)
184 dout(10) << "have_past_parents_open [" << first
<< "," << last
<< "]" << dendl
;
188 for (map
<snapid_t
, snaplink_t
>::iterator p
= srnode
.past_parents
.lower_bound(first
);
189 p
!= srnode
.past_parents
.end();
191 if (p
->second
.first
> last
)
193 dout(10) << " past parent [" << p
->second
.first
<< "," << p
->first
<< "] was "
194 << p
->second
.ino
<< dendl
;
195 if (open_past_parents
.count(p
->second
.ino
) == 0) {
196 dout(10) << " past parent " << p
->second
.ino
<< " is not open" << dendl
;
199 SnapRealm
*parent_realm
= open_past_parents
[p
->second
.ino
].first
;
200 if (!parent_realm
->have_past_parents_open(MAX(first
, p
->second
.first
),
201 MIN(last
, p
->first
)))
209 void SnapRealm::close_parents()
211 for (auto p
= open_past_parents
.begin(); p
!= open_past_parents
.end(); ++p
) {
212 num_open_past_parents
-= p
->second
.second
.size();
213 p
->second
.first
->inode
->put(CInode::PIN_PASTSNAPPARENT
);
214 p
->second
.first
->open_past_children
.erase(this);
216 open_past_parents
.clear();
221 * get list of snaps for this realm. we must include parents' snaps
222 * for the intervals during which they were our parent.
224 void SnapRealm::build_snap_set(set
<snapid_t
> &s
,
225 snapid_t
& max_seq
, snapid_t
& max_last_created
, snapid_t
& max_last_destroyed
,
226 snapid_t first
, snapid_t last
) const
228 dout(10) << "build_snap_set [" << first
<< "," << last
<< "] on " << *this << dendl
;
230 if (srnode
.seq
> max_seq
)
231 max_seq
= srnode
.seq
;
232 if (srnode
.last_created
> max_last_created
)
233 max_last_created
= srnode
.last_created
;
234 if (srnode
.last_destroyed
> max_last_destroyed
)
235 max_last_destroyed
= srnode
.last_destroyed
;
237 // include my snaps within interval [first,last]
238 for (map
<snapid_t
, SnapInfo
>::const_iterator p
= srnode
.snaps
.lower_bound(first
); // first element >= first
239 p
!= srnode
.snaps
.end() && p
->first
<= last
;
243 // include snaps for parents during intervals that intersect [first,last]
244 for (map
<snapid_t
, snaplink_t
>::const_iterator p
= srnode
.past_parents
.lower_bound(first
);
245 p
!= srnode
.past_parents
.end() && p
->first
>= first
&& p
->second
.first
<= last
;
247 const CInode
*oldparent
= mdcache
->get_inode(p
->second
.ino
);
248 assert(oldparent
); // call open_parents first!
249 assert(oldparent
->snaprealm
);
250 oldparent
->snaprealm
->build_snap_set(s
, max_seq
, max_last_created
, max_last_destroyed
,
251 MAX(first
, p
->second
.first
),
252 MIN(last
, p
->first
));
254 if (srnode
.current_parent_since
<= last
&& parent
)
255 parent
->build_snap_set(s
, max_seq
, max_last_created
, max_last_destroyed
,
256 MAX(first
, srnode
.current_parent_since
), last
);
260 void SnapRealm::check_cache() const
263 if (cached_seq
>= srnode
.seq
)
266 cached_snaps
.clear();
267 cached_snap_context
.clear();
269 cached_last_created
= srnode
.last_created
;
270 cached_last_destroyed
= srnode
.last_destroyed
;
271 cached_seq
= srnode
.seq
;
272 build_snap_set(cached_snaps
, cached_seq
, cached_last_created
, cached_last_destroyed
,
275 cached_snap_trace
.clear();
276 build_snap_trace(cached_snap_trace
);
278 dout(10) << "check_cache rebuilt " << cached_snaps
279 << " seq " << srnode
.seq
280 << " cached_seq " << cached_seq
281 << " cached_last_created " << cached_last_created
282 << " cached_last_destroyed " << cached_last_destroyed
286 const set
<snapid_t
>& SnapRealm::get_snaps() const
289 dout(10) << "get_snaps " << cached_snaps
290 << " (seq " << srnode
.seq
<< " cached_seq " << cached_seq
<< ")"
296 * build vector in reverse sorted order
298 const SnapContext
& SnapRealm::get_snap_context() const
302 if (!cached_snap_context
.seq
) {
303 cached_snap_context
.seq
= cached_seq
;
304 cached_snap_context
.snaps
.resize(cached_snaps
.size());
306 for (set
<snapid_t
>::reverse_iterator p
= cached_snaps
.rbegin();
307 p
!= cached_snaps
.rend();
309 cached_snap_context
.snaps
[i
++] = *p
;
312 return cached_snap_context
;
315 void SnapRealm::get_snap_info(map
<snapid_t
,SnapInfo
*>& infomap
, snapid_t first
, snapid_t last
)
317 const set
<snapid_t
>& snaps
= get_snaps();
318 dout(10) << "get_snap_info snaps " << snaps
<< dendl
;
320 // include my snaps within interval [first,last]
321 for (map
<snapid_t
, SnapInfo
>::iterator p
= srnode
.snaps
.lower_bound(first
); // first element >= first
322 p
!= srnode
.snaps
.end() && p
->first
<= last
;
324 infomap
[p
->first
] = &p
->second
;
326 // include snaps for parents during intervals that intersect [first,last]
327 for (map
<snapid_t
, snaplink_t
>::iterator p
= srnode
.past_parents
.lower_bound(first
);
328 p
!= srnode
.past_parents
.end() && p
->first
>= first
&& p
->second
.first
<= last
;
330 CInode
*oldparent
= mdcache
->get_inode(p
->second
.ino
);
331 assert(oldparent
); // call open_parents first!
332 assert(oldparent
->snaprealm
);
333 oldparent
->snaprealm
->get_snap_info(infomap
,
334 MAX(first
, p
->second
.first
),
335 MIN(last
, p
->first
));
337 if (srnode
.current_parent_since
<= last
&& parent
)
338 parent
->get_snap_info(infomap
, MAX(first
, srnode
.current_parent_since
), last
);
341 const string
& SnapRealm::get_snapname(snapid_t snapid
, inodeno_t atino
)
343 auto srnode_snaps_entry
= srnode
.snaps
.find(snapid
);
344 if (srnode_snaps_entry
!= srnode
.snaps
.end()) {
345 if (atino
== inode
->ino())
346 return srnode_snaps_entry
->second
.name
;
348 return srnode_snaps_entry
->second
.get_long_name();
351 map
<snapid_t
,snaplink_t
>::iterator p
= srnode
.past_parents
.lower_bound(snapid
);
352 if (p
!= srnode
.past_parents
.end() && p
->second
.first
<= snapid
) {
353 CInode
*oldparent
= mdcache
->get_inode(p
->second
.ino
);
354 assert(oldparent
); // call open_parents first!
355 assert(oldparent
->snaprealm
);
356 return oldparent
->snaprealm
->get_snapname(snapid
, atino
);
359 assert(srnode
.current_parent_since
<= snapid
);
361 return parent
->get_snapname(snapid
, atino
);
364 snapid_t
SnapRealm::resolve_snapname(const string
& n
, inodeno_t atino
, snapid_t first
, snapid_t last
)
367 dout(10) << "resolve_snapname '" << n
<< "' in [" << first
<< "," << last
<< "]" << dendl
;
370 //if (n[0] == '~') num = atoll(n.c_str()+1);
372 bool actual
= (atino
== inode
->ino());
377 n
[0] != '_') return 0;
378 int next_
= n
.find('_', 1);
379 if (next_
< 0) return 0;
380 pname
= n
.substr(1, next_
- 1);
381 pino
= atoll(n
.c_str() + next_
+ 1);
382 dout(10) << " " << n
<< " parses to name '" << pname
<< "' dirino " << pino
<< dendl
;
385 for (map
<snapid_t
, SnapInfo
>::iterator p
= srnode
.snaps
.lower_bound(first
); // first element >= first
386 p
!= srnode
.snaps
.end() && p
->first
<= last
;
388 dout(15) << " ? " << p
->second
<< dendl
;
389 //if (num && p->second.snapid == num)
391 if (actual
&& p
->second
.name
== n
)
393 if (!actual
&& p
->second
.name
== pname
&& p
->second
.ino
== pino
)
397 // include snaps for parents during intervals that intersect [first,last]
398 for (map
<snapid_t
, snaplink_t
>::iterator p
= srnode
.past_parents
.lower_bound(first
);
399 p
!= srnode
.past_parents
.end() && p
->first
>= first
&& p
->second
.first
<= last
;
401 CInode
*oldparent
= mdcache
->get_inode(p
->second
.ino
);
402 assert(oldparent
); // call open_parents first!
403 assert(oldparent
->snaprealm
);
404 snapid_t r
= oldparent
->snaprealm
->resolve_snapname(n
, atino
,
405 MAX(first
, p
->second
.first
),
406 MIN(last
, p
->first
));
410 if (parent
&& srnode
.current_parent_since
<= last
)
411 return parent
->resolve_snapname(n
, atino
, MAX(first
, srnode
.current_parent_since
), last
);
416 void SnapRealm::adjust_parent()
418 SnapRealm
*newparent
= inode
->get_parent_dn()->get_dir()->get_inode()->find_snaprealm();
419 if (newparent
!= parent
) {
420 dout(10) << "adjust_parent " << parent
<< " -> " << newparent
<< dendl
;
422 parent
->open_children
.erase(this);
425 parent
->open_children
.insert(this);
427 invalidate_cached_snaps();
431 void SnapRealm::split_at(SnapRealm
*child
)
433 dout(10) << "split_at " << *child
434 << " on " << *child
->inode
<< dendl
;
436 if (inode
->is_mdsdir() || !child
->inode
->is_dir()) {
438 if (child
->inode
->containing_realm
) {
439 // - no open children.
440 // - only need to move this child's inode's caps.
441 child
->inode
->move_to_realm(child
);
443 // no caps, nothing to move/split.
444 dout(20) << " split no-op, no caps to move on file " << *child
->inode
<< dendl
;
445 assert(!child
->inode
->is_any_caps());
452 // split open_children
453 dout(10) << " open_children are " << open_children
<< dendl
;
454 for (set
<SnapRealm
*>::iterator p
= open_children
.begin();
455 p
!= open_children
.end(); ) {
456 SnapRealm
*realm
= *p
;
457 if (realm
!= child
&&
458 child
->inode
->is_projected_ancestor_of(realm
->inode
)) {
459 dout(20) << " child gets child realm " << *realm
<< " on " << *realm
->inode
<< dendl
;
460 realm
->parent
= child
;
461 child
->open_children
.insert(realm
);
462 open_children
.erase(p
++);
464 dout(20) << " keeping child realm " << *realm
<< " on " << *realm
->inode
<< dendl
;
469 // split inodes_with_caps
470 elist
<CInode
*>::iterator p
= inodes_with_caps
.begin(member_offset(CInode
, item_caps
));
475 // does inode fall within the child realm?
476 bool under_child
= false;
478 if (in
== child
->inode
) {
482 while (t
->get_parent_dn()) {
483 t
= t
->get_parent_dn()->get_dir()->get_inode();
484 if (t
== child
->inode
) {
493 dout(20) << " child gets " << *in
<< dendl
;
494 in
->move_to_realm(child
);
496 dout(20) << " keeping " << *in
<< dendl
;
502 const bufferlist
& SnapRealm::get_snap_trace()
505 return cached_snap_trace
;
508 void SnapRealm::build_snap_trace(bufferlist
& snapbl
) const
510 SnapRealmInfo
info(inode
->ino(), srnode
.created
, srnode
.seq
, srnode
.current_parent_since
);
513 info
.h
.parent
= parent
->inode
->ino();
514 if (!srnode
.past_parents
.empty()) {
515 snapid_t last
= srnode
.past_parents
.rbegin()->first
;
517 snapid_t max_seq
, max_last_created
, max_last_destroyed
;
518 build_snap_set(past
, max_seq
, max_last_created
, max_last_destroyed
, 0, last
);
519 info
.prior_parent_snaps
.reserve(past
.size());
520 for (set
<snapid_t
>::reverse_iterator p
= past
.rbegin(); p
!= past
.rend(); ++p
)
521 info
.prior_parent_snaps
.push_back(*p
);
522 dout(10) << "build_snap_trace prior_parent_snaps from [1," << last
<< "] "
523 << info
.prior_parent_snaps
<< dendl
;
528 info
.my_snaps
.reserve(srnode
.snaps
.size());
529 for (map
<snapid_t
,SnapInfo
>::const_reverse_iterator p
= srnode
.snaps
.rbegin();
530 p
!= srnode
.snaps
.rend();
532 info
.my_snaps
.push_back(p
->first
);
533 dout(10) << "build_snap_trace my_snaps " << info
.my_snaps
<< dendl
;
535 ::encode(info
, snapbl
);
538 parent
->build_snap_trace(snapbl
);
543 void SnapRealm::prune_past_parents()
545 dout(10) << "prune_past_parents" << dendl
;
549 map
<snapid_t
, snaplink_t
>::iterator p
= srnode
.past_parents
.begin();
550 while (p
!= srnode
.past_parents
.end()) {
551 set
<snapid_t
>::iterator q
= cached_snaps
.lower_bound(p
->second
.first
);
552 if (q
== cached_snaps
.end() ||
554 dout(10) << "prune_past_parents pruning [" << p
->second
.first
<< "," << p
->first
555 << "] " << p
->second
.ino
<< dendl
;
556 remove_open_past_parent(p
->second
.ino
, p
->first
);
557 srnode
.past_parents
.erase(p
++);
559 dout(10) << "prune_past_parents keeping [" << p
->second
.first
<< "," << p
->first
560 << "] " << p
->second
.ino
<< dendl
;