]>
Commit | Line | Data |
---|---|---|
3d14c5d2 | 1 | #include <linux/ceph/ceph_debug.h> |
963b61eb | 2 | |
963b61eb | 3 | #include <linux/sort.h> |
5a0e3ad6 | 4 | #include <linux/slab.h> |
963b61eb SW |
5 | |
6 | #include "super.h" | |
3d14c5d2 YS |
7 | #include "mds_client.h" |
8 | ||
9 | #include <linux/ceph/decode.h> | |
963b61eb SW |
10 | |
11 | /* | |
12 | * Snapshots in ceph are driven in large part by cooperation from the | |
13 | * client. In contrast to local file systems or file servers that | |
14 | * implement snapshots at a single point in the system, ceph's | |
15 | * distributed access to storage requires clients to help decide | |
16 | * whether a write logically occurs before or after a recently created | |
17 | * snapshot. | |
18 | * | |
19 | * This provides a perfect instantanous client-wide snapshot. Between | |
20 | * clients, however, snapshots may appear to be applied at slightly | |
21 | * different points in time, depending on delays in delivering the | |
22 | * snapshot notification. | |
23 | * | |
24 | * Snapshots are _not_ file system-wide. Instead, each snapshot | |
25 | * applies to the subdirectory nested beneath some directory. This | |
26 | * effectively divides the hierarchy into multiple "realms," where all | |
27 | * of the files contained by each realm share the same set of | |
28 | * snapshots. An individual realm's snap set contains snapshots | |
29 | * explicitly created on that realm, as well as any snaps in its | |
30 | * parent's snap set _after_ the point at which the parent became it's | |
31 | * parent (due to, say, a rename). Similarly, snaps from prior parents | |
32 | * during the time intervals during which they were the parent are included. | |
33 | * | |
34 | * The client is spared most of this detail, fortunately... it must only | |
35 | * maintains a hierarchy of realms reflecting the current parent/child | |
36 | * realm relationship, and for each realm has an explicit list of snaps | |
37 | * inherited from prior parents. | |
38 | * | |
39 | * A snap_realm struct is maintained for realms containing every inode | |
40 | * with an open cap in the system. (The needed snap realm information is | |
41 | * provided by the MDS whenever a cap is issued, i.e., on open.) A 'seq' | |
42 | * version number is used to ensure that as realm parameters change (new | |
43 | * snapshot, new parent, etc.) the client's realm hierarchy is updated. | |
44 | * | |
45 | * The realm hierarchy drives the generation of a 'snap context' for each | |
46 | * realm, which simply lists the resulting set of snaps for the realm. This | |
47 | * is attached to any writes sent to OSDs. | |
48 | */ | |
49 | /* | |
50 | * Unfortunately error handling is a bit mixed here. If we get a snap | |
51 | * update, but don't have enough memory to update our realm hierarchy, | |
52 | * it's not clear what we can do about it (besides complaining to the | |
53 | * console). | |
54 | */ | |
55 | ||
56 | ||
57 | /* | |
58 | * increase ref count for the realm | |
59 | * | |
60 | * caller must hold snap_rwsem for write. | |
61 | */ | |
62 | void ceph_get_snap_realm(struct ceph_mds_client *mdsc, | |
63 | struct ceph_snap_realm *realm) | |
64 | { | |
65 | dout("get_realm %p %d -> %d\n", realm, | |
66 | atomic_read(&realm->nref), atomic_read(&realm->nref)+1); | |
67 | /* | |
68 | * since we _only_ increment realm refs or empty the empty | |
69 | * list with snap_rwsem held, adjusting the empty list here is | |
70 | * safe. we do need to protect against concurrent empty list | |
71 | * additions, however. | |
72 | */ | |
982d6011 | 73 | if (atomic_inc_return(&realm->nref) == 1) { |
963b61eb SW |
74 | spin_lock(&mdsc->snap_empty_lock); |
75 | list_del_init(&realm->empty_item); | |
76 | spin_unlock(&mdsc->snap_empty_lock); | |
77 | } | |
963b61eb SW |
78 | } |
79 | ||
a105f00c SW |
80 | static void __insert_snap_realm(struct rb_root *root, |
81 | struct ceph_snap_realm *new) | |
82 | { | |
83 | struct rb_node **p = &root->rb_node; | |
84 | struct rb_node *parent = NULL; | |
85 | struct ceph_snap_realm *r = NULL; | |
86 | ||
87 | while (*p) { | |
88 | parent = *p; | |
89 | r = rb_entry(parent, struct ceph_snap_realm, node); | |
90 | if (new->ino < r->ino) | |
91 | p = &(*p)->rb_left; | |
92 | else if (new->ino > r->ino) | |
93 | p = &(*p)->rb_right; | |
94 | else | |
95 | BUG(); | |
96 | } | |
97 | ||
98 | rb_link_node(&new->node, parent, p); | |
99 | rb_insert_color(&new->node, root); | |
100 | } | |
101 | ||
963b61eb SW |
102 | /* |
103 | * create and get the realm rooted at @ino and bump its ref count. | |
104 | * | |
105 | * caller must hold snap_rwsem for write. | |
106 | */ | |
107 | static struct ceph_snap_realm *ceph_create_snap_realm( | |
108 | struct ceph_mds_client *mdsc, | |
109 | u64 ino) | |
110 | { | |
111 | struct ceph_snap_realm *realm; | |
112 | ||
113 | realm = kzalloc(sizeof(*realm), GFP_NOFS); | |
114 | if (!realm) | |
115 | return ERR_PTR(-ENOMEM); | |
116 | ||
982d6011 | 117 | atomic_set(&realm->nref, 1); /* for caller */ |
963b61eb SW |
118 | realm->ino = ino; |
119 | INIT_LIST_HEAD(&realm->children); | |
120 | INIT_LIST_HEAD(&realm->child_item); | |
121 | INIT_LIST_HEAD(&realm->empty_item); | |
ae00d4f3 | 122 | INIT_LIST_HEAD(&realm->dirty_item); |
963b61eb SW |
123 | INIT_LIST_HEAD(&realm->inodes_with_caps); |
124 | spin_lock_init(&realm->inodes_with_caps_lock); | |
a105f00c | 125 | __insert_snap_realm(&mdsc->snap_realms, realm); |
963b61eb SW |
126 | dout("create_snap_realm %llx %p\n", realm->ino, realm); |
127 | return realm; | |
128 | } | |
129 | ||
130 | /* | |
a105f00c | 131 | * lookup the realm rooted at @ino. |
963b61eb SW |
132 | * |
133 | * caller must hold snap_rwsem for write. | |
134 | */ | |
982d6011 YZ |
135 | static struct ceph_snap_realm *__lookup_snap_realm(struct ceph_mds_client *mdsc, |
136 | u64 ino) | |
963b61eb | 137 | { |
a105f00c SW |
138 | struct rb_node *n = mdsc->snap_realms.rb_node; |
139 | struct ceph_snap_realm *r; | |
140 | ||
141 | while (n) { | |
142 | r = rb_entry(n, struct ceph_snap_realm, node); | |
143 | if (ino < r->ino) | |
144 | n = n->rb_left; | |
145 | else if (ino > r->ino) | |
146 | n = n->rb_right; | |
147 | else { | |
148 | dout("lookup_snap_realm %llx %p\n", r->ino, r); | |
149 | return r; | |
150 | } | |
151 | } | |
152 | return NULL; | |
963b61eb SW |
153 | } |
154 | ||
982d6011 YZ |
155 | struct ceph_snap_realm *ceph_lookup_snap_realm(struct ceph_mds_client *mdsc, |
156 | u64 ino) | |
157 | { | |
158 | struct ceph_snap_realm *r; | |
159 | r = __lookup_snap_realm(mdsc, ino); | |
160 | if (r) | |
161 | ceph_get_snap_realm(mdsc, r); | |
162 | return r; | |
163 | } | |
164 | ||
963b61eb SW |
165 | static void __put_snap_realm(struct ceph_mds_client *mdsc, |
166 | struct ceph_snap_realm *realm); | |
167 | ||
168 | /* | |
169 | * called with snap_rwsem (write) | |
170 | */ | |
171 | static void __destroy_snap_realm(struct ceph_mds_client *mdsc, | |
172 | struct ceph_snap_realm *realm) | |
173 | { | |
174 | dout("__destroy_snap_realm %p %llx\n", realm, realm->ino); | |
175 | ||
a105f00c | 176 | rb_erase(&realm->node, &mdsc->snap_realms); |
963b61eb SW |
177 | |
178 | if (realm->parent) { | |
179 | list_del_init(&realm->child_item); | |
180 | __put_snap_realm(mdsc, realm->parent); | |
181 | } | |
182 | ||
183 | kfree(realm->prior_parent_snaps); | |
184 | kfree(realm->snaps); | |
185 | ceph_put_snap_context(realm->cached_context); | |
186 | kfree(realm); | |
187 | } | |
188 | ||
189 | /* | |
190 | * caller holds snap_rwsem (write) | |
191 | */ | |
192 | static void __put_snap_realm(struct ceph_mds_client *mdsc, | |
193 | struct ceph_snap_realm *realm) | |
194 | { | |
195 | dout("__put_snap_realm %llx %p %d -> %d\n", realm->ino, realm, | |
196 | atomic_read(&realm->nref), atomic_read(&realm->nref)-1); | |
197 | if (atomic_dec_and_test(&realm->nref)) | |
198 | __destroy_snap_realm(mdsc, realm); | |
199 | } | |
200 | ||
201 | /* | |
202 | * caller needn't hold any locks | |
203 | */ | |
204 | void ceph_put_snap_realm(struct ceph_mds_client *mdsc, | |
205 | struct ceph_snap_realm *realm) | |
206 | { | |
207 | dout("put_snap_realm %llx %p %d -> %d\n", realm->ino, realm, | |
208 | atomic_read(&realm->nref), atomic_read(&realm->nref)-1); | |
209 | if (!atomic_dec_and_test(&realm->nref)) | |
210 | return; | |
211 | ||
212 | if (down_write_trylock(&mdsc->snap_rwsem)) { | |
213 | __destroy_snap_realm(mdsc, realm); | |
214 | up_write(&mdsc->snap_rwsem); | |
215 | } else { | |
216 | spin_lock(&mdsc->snap_empty_lock); | |
a26a185d | 217 | list_add(&realm->empty_item, &mdsc->snap_empty); |
963b61eb SW |
218 | spin_unlock(&mdsc->snap_empty_lock); |
219 | } | |
220 | } | |
221 | ||
222 | /* | |
223 | * Clean up any realms whose ref counts have dropped to zero. Note | |
224 | * that this does not include realms who were created but not yet | |
225 | * used. | |
226 | * | |
227 | * Called under snap_rwsem (write) | |
228 | */ | |
229 | static void __cleanup_empty_realms(struct ceph_mds_client *mdsc) | |
230 | { | |
231 | struct ceph_snap_realm *realm; | |
232 | ||
233 | spin_lock(&mdsc->snap_empty_lock); | |
234 | while (!list_empty(&mdsc->snap_empty)) { | |
235 | realm = list_first_entry(&mdsc->snap_empty, | |
236 | struct ceph_snap_realm, empty_item); | |
237 | list_del(&realm->empty_item); | |
238 | spin_unlock(&mdsc->snap_empty_lock); | |
239 | __destroy_snap_realm(mdsc, realm); | |
240 | spin_lock(&mdsc->snap_empty_lock); | |
241 | } | |
242 | spin_unlock(&mdsc->snap_empty_lock); | |
243 | } | |
244 | ||
245 | void ceph_cleanup_empty_realms(struct ceph_mds_client *mdsc) | |
246 | { | |
247 | down_write(&mdsc->snap_rwsem); | |
248 | __cleanup_empty_realms(mdsc); | |
249 | up_write(&mdsc->snap_rwsem); | |
250 | } | |
251 | ||
252 | /* | |
253 | * adjust the parent realm of a given @realm. adjust child list, and parent | |
254 | * pointers, and ref counts appropriately. | |
255 | * | |
256 | * return true if parent was changed, 0 if unchanged, <0 on error. | |
257 | * | |
258 | * caller must hold snap_rwsem for write. | |
259 | */ | |
260 | static int adjust_snap_realm_parent(struct ceph_mds_client *mdsc, | |
261 | struct ceph_snap_realm *realm, | |
262 | u64 parentino) | |
263 | { | |
264 | struct ceph_snap_realm *parent; | |
265 | ||
266 | if (realm->parent_ino == parentino) | |
267 | return 0; | |
268 | ||
269 | parent = ceph_lookup_snap_realm(mdsc, parentino); | |
963b61eb SW |
270 | if (!parent) { |
271 | parent = ceph_create_snap_realm(mdsc, parentino); | |
272 | if (IS_ERR(parent)) | |
273 | return PTR_ERR(parent); | |
274 | } | |
275 | dout("adjust_snap_realm_parent %llx %p: %llx %p -> %llx %p\n", | |
276 | realm->ino, realm, realm->parent_ino, realm->parent, | |
277 | parentino, parent); | |
278 | if (realm->parent) { | |
279 | list_del_init(&realm->child_item); | |
280 | ceph_put_snap_realm(mdsc, realm->parent); | |
281 | } | |
282 | realm->parent_ino = parentino; | |
283 | realm->parent = parent; | |
963b61eb SW |
284 | list_add(&realm->child_item, &parent->children); |
285 | return 1; | |
286 | } | |
287 | ||
288 | ||
289 | static int cmpu64_rev(const void *a, const void *b) | |
290 | { | |
291 | if (*(u64 *)a < *(u64 *)b) | |
292 | return 1; | |
293 | if (*(u64 *)a > *(u64 *)b) | |
294 | return -1; | |
295 | return 0; | |
296 | } | |
297 | ||
97c85a82 | 298 | |
7b06a826 | 299 | struct ceph_snap_context *ceph_empty_snapc; |
97c85a82 | 300 | |
963b61eb SW |
301 | /* |
302 | * build the snap context for a given realm. | |
303 | */ | |
304 | static int build_snap_context(struct ceph_snap_realm *realm) | |
305 | { | |
306 | struct ceph_snap_realm *parent = realm->parent; | |
307 | struct ceph_snap_context *snapc; | |
308 | int err = 0; | |
aa711ee3 | 309 | u32 num = realm->num_prior_parent_snaps + realm->num_snaps; |
963b61eb SW |
310 | |
311 | /* | |
312 | * build parent context, if it hasn't been built. | |
313 | * conservatively estimate that all parent snaps might be | |
314 | * included by us. | |
315 | */ | |
316 | if (parent) { | |
317 | if (!parent->cached_context) { | |
318 | err = build_snap_context(parent); | |
319 | if (err) | |
320 | goto fail; | |
321 | } | |
322 | num += parent->cached_context->num_snaps; | |
323 | } | |
324 | ||
325 | /* do i actually need to update? not if my context seq | |
326 | matches realm seq, and my parents' does to. (this works | |
327 | because we rebuild_snap_realms() works _downward_ in | |
328 | hierarchy after each update.) */ | |
329 | if (realm->cached_context && | |
ec4318bc | 330 | realm->cached_context->seq == realm->seq && |
963b61eb | 331 | (!parent || |
ec4318bc | 332 | realm->cached_context->seq >= parent->cached_context->seq)) { |
aa711ee3 | 333 | dout("build_snap_context %llx %p: %p seq %lld (%u snaps)" |
963b61eb SW |
334 | " (unchanged)\n", |
335 | realm->ino, realm, realm->cached_context, | |
336 | realm->cached_context->seq, | |
aa711ee3 | 337 | (unsigned int) realm->cached_context->num_snaps); |
963b61eb SW |
338 | return 0; |
339 | } | |
340 | ||
7b06a826 YZ |
341 | if (num == 0 && realm->seq == ceph_empty_snapc->seq) { |
342 | ceph_get_snap_context(ceph_empty_snapc); | |
343 | snapc = ceph_empty_snapc; | |
97c85a82 YZ |
344 | goto done; |
345 | } | |
346 | ||
963b61eb SW |
347 | /* alloc new snap context */ |
348 | err = -ENOMEM; | |
a3860c1c | 349 | if (num > (SIZE_MAX - sizeof(*snapc)) / sizeof(u64)) |
963b61eb | 350 | goto fail; |
812164f8 | 351 | snapc = ceph_create_snap_context(num, GFP_NOFS); |
963b61eb SW |
352 | if (!snapc) |
353 | goto fail; | |
963b61eb SW |
354 | |
355 | /* build (reverse sorted) snap vector */ | |
356 | num = 0; | |
357 | snapc->seq = realm->seq; | |
358 | if (parent) { | |
aa711ee3 AE |
359 | u32 i; |
360 | ||
25985edc | 361 | /* include any of parent's snaps occurring _after_ my |
963b61eb SW |
362 | parent became my parent */ |
363 | for (i = 0; i < parent->cached_context->num_snaps; i++) | |
364 | if (parent->cached_context->snaps[i] >= | |
365 | realm->parent_since) | |
366 | snapc->snaps[num++] = | |
367 | parent->cached_context->snaps[i]; | |
368 | if (parent->cached_context->seq > snapc->seq) | |
369 | snapc->seq = parent->cached_context->seq; | |
370 | } | |
371 | memcpy(snapc->snaps + num, realm->snaps, | |
372 | sizeof(u64)*realm->num_snaps); | |
373 | num += realm->num_snaps; | |
374 | memcpy(snapc->snaps + num, realm->prior_parent_snaps, | |
375 | sizeof(u64)*realm->num_prior_parent_snaps); | |
376 | num += realm->num_prior_parent_snaps; | |
377 | ||
378 | sort(snapc->snaps, num, sizeof(u64), cmpu64_rev, NULL); | |
379 | snapc->num_snaps = num; | |
aa711ee3 AE |
380 | dout("build_snap_context %llx %p: %p seq %lld (%u snaps)\n", |
381 | realm->ino, realm, snapc, snapc->seq, | |
382 | (unsigned int) snapc->num_snaps); | |
963b61eb | 383 | |
97c85a82 | 384 | done: |
e96a650a | 385 | ceph_put_snap_context(realm->cached_context); |
963b61eb SW |
386 | realm->cached_context = snapc; |
387 | return 0; | |
388 | ||
389 | fail: | |
390 | /* | |
391 | * if we fail, clear old (incorrect) cached_context... hopefully | |
392 | * we'll have better luck building it later | |
393 | */ | |
394 | if (realm->cached_context) { | |
395 | ceph_put_snap_context(realm->cached_context); | |
396 | realm->cached_context = NULL; | |
397 | } | |
398 | pr_err("build_snap_context %llx %p fail %d\n", realm->ino, | |
399 | realm, err); | |
400 | return err; | |
401 | } | |
402 | ||
403 | /* | |
404 | * rebuild snap context for the given realm and all of its children. | |
405 | */ | |
406 | static void rebuild_snap_realms(struct ceph_snap_realm *realm) | |
407 | { | |
408 | struct ceph_snap_realm *child; | |
409 | ||
410 | dout("rebuild_snap_realms %llx %p\n", realm->ino, realm); | |
411 | build_snap_context(realm); | |
412 | ||
413 | list_for_each_entry(child, &realm->children, child_item) | |
414 | rebuild_snap_realms(child); | |
415 | } | |
416 | ||
417 | ||
418 | /* | |
419 | * helper to allocate and decode an array of snapids. free prior | |
420 | * instance, if any. | |
421 | */ | |
aa711ee3 | 422 | static int dup_array(u64 **dst, __le64 *src, u32 num) |
963b61eb | 423 | { |
aa711ee3 | 424 | u32 i; |
963b61eb SW |
425 | |
426 | kfree(*dst); | |
427 | if (num) { | |
428 | *dst = kcalloc(num, sizeof(u64), GFP_NOFS); | |
429 | if (!*dst) | |
430 | return -ENOMEM; | |
431 | for (i = 0; i < num; i++) | |
432 | (*dst)[i] = get_unaligned_le64(src + i); | |
433 | } else { | |
434 | *dst = NULL; | |
435 | } | |
436 | return 0; | |
437 | } | |
438 | ||
86056090 YZ |
439 | static bool has_new_snaps(struct ceph_snap_context *o, |
440 | struct ceph_snap_context *n) | |
441 | { | |
442 | if (n->num_snaps == 0) | |
443 | return false; | |
444 | /* snaps are in descending order */ | |
445 | return n->snaps[0] > o->seq; | |
446 | } | |
963b61eb SW |
447 | |
448 | /* | |
449 | * When a snapshot is applied, the size/mtime inode metadata is queued | |
450 | * in a ceph_cap_snap (one for each snapshot) until writeback | |
451 | * completes and the metadata can be flushed back to the MDS. | |
452 | * | |
453 | * However, if a (sync) write is currently in-progress when we apply | |
454 | * the snapshot, we have to wait until the write succeeds or fails | |
455 | * (and a final size/mtime is known). In this case the | |
456 | * cap_snap->writing = 1, and is said to be "pending." When the write | |
457 | * finishes, we __ceph_finish_cap_snap(). | |
458 | * | |
459 | * Caller must hold snap_rwsem for read (i.e., the realm topology won't | |
460 | * change). | |
461 | */ | |
fc837c8f | 462 | void ceph_queue_cap_snap(struct ceph_inode_info *ci) |
963b61eb SW |
463 | { |
464 | struct inode *inode = &ci->vfs_inode; | |
465 | struct ceph_cap_snap *capsnap; | |
86056090 | 466 | struct ceph_snap_context *old_snapc, *new_snapc; |
4a625be4 | 467 | int used, dirty; |
963b61eb SW |
468 | |
469 | capsnap = kzalloc(sizeof(*capsnap), GFP_NOFS); | |
470 | if (!capsnap) { | |
471 | pr_err("ENOMEM allocating ceph_cap_snap on %p\n", inode); | |
472 | return; | |
473 | } | |
474 | ||
be655596 | 475 | spin_lock(&ci->i_ceph_lock); |
963b61eb | 476 | used = __ceph_caps_used(ci); |
4a625be4 | 477 | dirty = __ceph_caps_dirty(ci); |
af0ed569 | 478 | |
5dda377c | 479 | old_snapc = ci->i_head_snapc; |
86056090 | 480 | new_snapc = ci->i_snap_realm->cached_context; |
5dda377c | 481 | |
af0ed569 SW |
482 | /* |
483 | * If there is a write in progress, treat that as a dirty Fw, | |
484 | * even though it hasn't completed yet; by the time we finish | |
485 | * up this capsnap it will be. | |
486 | */ | |
487 | if (used & CEPH_CAP_FILE_WR) | |
488 | dirty |= CEPH_CAP_FILE_WR; | |
489 | ||
963b61eb SW |
490 | if (__ceph_have_pending_cap_snap(ci)) { |
491 | /* there is no point in queuing multiple "pending" cap_snaps, | |
492 | as no new writes are allowed to start when pending, so any | |
493 | writes in progress now were started before the previous | |
494 | cap_snap. lucky us. */ | |
fc837c8f | 495 | dout("queue_cap_snap %p already pending\n", inode); |
5dda377c YZ |
496 | goto update_snapc; |
497 | } | |
86056090 YZ |
498 | if (ci->i_wrbuffer_ref_head == 0 && |
499 | !(dirty & (CEPH_CAP_ANY_EXCL|CEPH_CAP_FILE_WR))) { | |
5dda377c YZ |
500 | dout("queue_cap_snap %p nothing dirty|writing\n", inode); |
501 | goto update_snapc; | |
502 | } | |
963b61eb | 503 | |
5dda377c | 504 | BUG_ON(!old_snapc); |
e20d258d | 505 | |
86056090 YZ |
506 | /* |
507 | * There is no need to send FLUSHSNAP message to MDS if there is | |
508 | * no new snapshot. But when there is dirty pages or on-going | |
509 | * writes, we still need to create cap_snap. cap_snap is needed | |
510 | * by the write path and page writeback path. | |
511 | * | |
512 | * also see ceph_try_drop_cap_snap() | |
513 | */ | |
514 | if (has_new_snaps(old_snapc, new_snapc)) { | |
515 | if (dirty & (CEPH_CAP_ANY_EXCL|CEPH_CAP_FILE_WR)) | |
516 | capsnap->need_flush = true; | |
517 | } else { | |
518 | if (!(used & CEPH_CAP_FILE_WR) && | |
519 | ci->i_wrbuffer_ref_head == 0) { | |
520 | dout("queue_cap_snap %p " | |
521 | "no new_snap|dirty_page|writing\n", inode); | |
522 | goto update_snapc; | |
523 | } | |
524 | } | |
525 | ||
526 | dout("queue_cap_snap %p cap_snap %p queuing under %p %s %s\n", | |
527 | inode, capsnap, old_snapc, ceph_cap_string(dirty), | |
528 | capsnap->need_flush ? "" : "no_flush"); | |
5dda377c YZ |
529 | ihold(inode); |
530 | ||
531 | atomic_set(&capsnap->nref, 1); | |
532 | capsnap->ci = ci; | |
533 | INIT_LIST_HEAD(&capsnap->ci_item); | |
534 | INIT_LIST_HEAD(&capsnap->flushing_item); | |
535 | ||
536 | capsnap->follows = old_snapc->seq; | |
537 | capsnap->issued = __ceph_caps_issued(ci, NULL); | |
538 | capsnap->dirty = dirty; | |
539 | ||
540 | capsnap->mode = inode->i_mode; | |
541 | capsnap->uid = inode->i_uid; | |
542 | capsnap->gid = inode->i_gid; | |
543 | ||
544 | if (dirty & CEPH_CAP_XATTR_EXCL) { | |
545 | __ceph_build_xattrs_blob(ci); | |
546 | capsnap->xattr_blob = | |
547 | ceph_buffer_get(ci->i_xattrs.blob); | |
548 | capsnap->xattr_version = ci->i_xattrs.version; | |
963b61eb | 549 | } else { |
5dda377c YZ |
550 | capsnap->xattr_blob = NULL; |
551 | capsnap->xattr_version = 0; | |
963b61eb SW |
552 | } |
553 | ||
5dda377c YZ |
554 | capsnap->inline_data = ci->i_inline_version != CEPH_INLINE_NONE; |
555 | ||
556 | /* dirty page count moved from _head to this cap_snap; | |
557 | all subsequent writes page dirties occur _after_ this | |
558 | snapshot. */ | |
559 | capsnap->dirty_pages = ci->i_wrbuffer_ref_head; | |
560 | ci->i_wrbuffer_ref_head = 0; | |
561 | capsnap->context = old_snapc; | |
562 | list_add_tail(&capsnap->ci_item, &ci->i_cap_snaps); | |
563 | old_snapc = NULL; | |
564 | ||
565 | if (used & CEPH_CAP_FILE_WR) { | |
566 | dout("queue_cap_snap %p cap_snap %p snapc %p" | |
567 | " seq %llu used WR, now pending\n", inode, | |
568 | capsnap, old_snapc, old_snapc->seq); | |
569 | capsnap->writing = 1; | |
570 | } else { | |
571 | /* note mtime, size NOW. */ | |
572 | __ceph_finish_cap_snap(ci, capsnap); | |
573 | } | |
574 | capsnap = NULL; | |
575 | ||
576 | update_snapc: | |
577 | if (ci->i_head_snapc) { | |
86056090 YZ |
578 | ci->i_head_snapc = ceph_get_snap_context(new_snapc); |
579 | dout(" new snapc is %p\n", new_snapc); | |
5dda377c | 580 | } |
be655596 | 581 | spin_unlock(&ci->i_ceph_lock); |
5dda377c YZ |
582 | |
583 | kfree(capsnap); | |
584 | ceph_put_snap_context(old_snapc); | |
963b61eb SW |
585 | } |
586 | ||
587 | /* | |
588 | * Finalize the size, mtime for a cap_snap.. that is, settle on final values | |
589 | * to be used for the snapshot, to be flushed back to the mds. | |
590 | * | |
591 | * If capsnap can now be flushed, add to snap_flush list, and return 1. | |
592 | * | |
be655596 | 593 | * Caller must hold i_ceph_lock. |
963b61eb SW |
594 | */ |
595 | int __ceph_finish_cap_snap(struct ceph_inode_info *ci, | |
596 | struct ceph_cap_snap *capsnap) | |
597 | { | |
598 | struct inode *inode = &ci->vfs_inode; | |
3d14c5d2 | 599 | struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc; |
963b61eb SW |
600 | |
601 | BUG_ON(capsnap->writing); | |
602 | capsnap->size = inode->i_size; | |
603 | capsnap->mtime = inode->i_mtime; | |
604 | capsnap->atime = inode->i_atime; | |
605 | capsnap->ctime = inode->i_ctime; | |
606 | capsnap->time_warp_seq = ci->i_time_warp_seq; | |
607 | if (capsnap->dirty_pages) { | |
819ccbfa | 608 | dout("finish_cap_snap %p cap_snap %p snapc %p %llu %s s=%llu " |
963b61eb SW |
609 | "still has %d dirty pages\n", inode, capsnap, |
610 | capsnap->context, capsnap->context->seq, | |
819ccbfa SW |
611 | ceph_cap_string(capsnap->dirty), capsnap->size, |
612 | capsnap->dirty_pages); | |
963b61eb SW |
613 | return 0; |
614 | } | |
819ccbfa | 615 | dout("finish_cap_snap %p cap_snap %p snapc %p %llu %s s=%llu\n", |
963b61eb | 616 | inode, capsnap, capsnap->context, |
819ccbfa SW |
617 | capsnap->context->seq, ceph_cap_string(capsnap->dirty), |
618 | capsnap->size); | |
963b61eb SW |
619 | |
620 | spin_lock(&mdsc->snap_flush_lock); | |
621 | list_add_tail(&ci->i_snap_flush_item, &mdsc->snap_flush_list); | |
622 | spin_unlock(&mdsc->snap_flush_lock); | |
623 | return 1; /* caller may want to ceph_flush_snaps */ | |
624 | } | |
625 | ||
ed326044 SW |
626 | /* |
627 | * Queue cap_snaps for snap writeback for this realm and its children. | |
628 | * Called under snap_rwsem, so realm topology won't change. | |
629 | */ | |
630 | static void queue_realm_cap_snaps(struct ceph_snap_realm *realm) | |
631 | { | |
632 | struct ceph_inode_info *ci; | |
633 | struct inode *lastinode = NULL; | |
634 | struct ceph_snap_realm *child; | |
635 | ||
636 | dout("queue_realm_cap_snaps %p %llx inodes\n", realm, realm->ino); | |
637 | ||
638 | spin_lock(&realm->inodes_with_caps_lock); | |
639 | list_for_each_entry(ci, &realm->inodes_with_caps, | |
640 | i_snap_realm_item) { | |
641 | struct inode *inode = igrab(&ci->vfs_inode); | |
642 | if (!inode) | |
643 | continue; | |
644 | spin_unlock(&realm->inodes_with_caps_lock); | |
e96a650a | 645 | iput(lastinode); |
ed326044 SW |
646 | lastinode = inode; |
647 | ceph_queue_cap_snap(ci); | |
648 | spin_lock(&realm->inodes_with_caps_lock); | |
649 | } | |
650 | spin_unlock(&realm->inodes_with_caps_lock); | |
e96a650a | 651 | iput(lastinode); |
ed326044 | 652 | |
e8e1ba96 SW |
653 | list_for_each_entry(child, &realm->children, child_item) { |
654 | dout("queue_realm_cap_snaps %p %llx queue child %p %llx\n", | |
655 | realm, realm->ino, child, child->ino); | |
656 | list_del_init(&child->dirty_item); | |
657 | list_add(&child->dirty_item, &realm->dirty_item); | |
658 | } | |
ed326044 | 659 | |
e8e1ba96 | 660 | list_del_init(&realm->dirty_item); |
ed326044 SW |
661 | dout("queue_realm_cap_snaps %p %llx done\n", realm, realm->ino); |
662 | } | |
963b61eb SW |
663 | |
664 | /* | |
665 | * Parse and apply a snapblob "snap trace" from the MDS. This specifies | |
666 | * the snap realm parameters from a given realm and all of its ancestors, | |
667 | * up to the root. | |
668 | * | |
669 | * Caller must hold snap_rwsem for write. | |
670 | */ | |
671 | int ceph_update_snap_trace(struct ceph_mds_client *mdsc, | |
982d6011 YZ |
672 | void *p, void *e, bool deletion, |
673 | struct ceph_snap_realm **realm_ret) | |
963b61eb SW |
674 | { |
675 | struct ceph_mds_snap_realm *ri; /* encoded */ | |
676 | __le64 *snaps; /* encoded */ | |
677 | __le64 *prior_parent_snaps; /* encoded */ | |
982d6011 YZ |
678 | struct ceph_snap_realm *realm = NULL; |
679 | struct ceph_snap_realm *first_realm = NULL; | |
963b61eb SW |
680 | int invalidate = 0; |
681 | int err = -ENOMEM; | |
ae00d4f3 | 682 | LIST_HEAD(dirty_realms); |
963b61eb SW |
683 | |
684 | dout("update_snap_trace deletion=%d\n", deletion); | |
685 | more: | |
686 | ceph_decode_need(&p, e, sizeof(*ri), bad); | |
687 | ri = p; | |
688 | p += sizeof(*ri); | |
689 | ceph_decode_need(&p, e, sizeof(u64)*(le32_to_cpu(ri->num_snaps) + | |
690 | le32_to_cpu(ri->num_prior_parent_snaps)), bad); | |
691 | snaps = p; | |
692 | p += sizeof(u64) * le32_to_cpu(ri->num_snaps); | |
693 | prior_parent_snaps = p; | |
694 | p += sizeof(u64) * le32_to_cpu(ri->num_prior_parent_snaps); | |
695 | ||
696 | realm = ceph_lookup_snap_realm(mdsc, le64_to_cpu(ri->ino)); | |
963b61eb SW |
697 | if (!realm) { |
698 | realm = ceph_create_snap_realm(mdsc, le64_to_cpu(ri->ino)); | |
699 | if (IS_ERR(realm)) { | |
700 | err = PTR_ERR(realm); | |
701 | goto fail; | |
702 | } | |
703 | } | |
704 | ||
963b61eb SW |
705 | /* ensure the parent is correct */ |
706 | err = adjust_snap_realm_parent(mdsc, realm, le64_to_cpu(ri->parent)); | |
707 | if (err < 0) | |
708 | goto fail; | |
709 | invalidate += err; | |
710 | ||
711 | if (le64_to_cpu(ri->seq) > realm->seq) { | |
ae00d4f3 SW |
712 | dout("update_snap_trace updating %llx %p %lld -> %lld\n", |
713 | realm->ino, realm, realm->seq, le64_to_cpu(ri->seq)); | |
963b61eb SW |
714 | /* update realm parameters, snap lists */ |
715 | realm->seq = le64_to_cpu(ri->seq); | |
716 | realm->created = le64_to_cpu(ri->created); | |
717 | realm->parent_since = le64_to_cpu(ri->parent_since); | |
718 | ||
719 | realm->num_snaps = le32_to_cpu(ri->num_snaps); | |
720 | err = dup_array(&realm->snaps, snaps, realm->num_snaps); | |
721 | if (err < 0) | |
722 | goto fail; | |
723 | ||
724 | realm->num_prior_parent_snaps = | |
725 | le32_to_cpu(ri->num_prior_parent_snaps); | |
726 | err = dup_array(&realm->prior_parent_snaps, prior_parent_snaps, | |
727 | realm->num_prior_parent_snaps); | |
728 | if (err < 0) | |
729 | goto fail; | |
730 | ||
ae00d4f3 SW |
731 | /* queue realm for cap_snap creation */ |
732 | list_add(&realm->dirty_item, &dirty_realms); | |
733 | ||
963b61eb SW |
734 | invalidate = 1; |
735 | } else if (!realm->cached_context) { | |
ae00d4f3 SW |
736 | dout("update_snap_trace %llx %p seq %lld new\n", |
737 | realm->ino, realm, realm->seq); | |
963b61eb | 738 | invalidate = 1; |
ae00d4f3 SW |
739 | } else { |
740 | dout("update_snap_trace %llx %p seq %lld unchanged\n", | |
741 | realm->ino, realm, realm->seq); | |
963b61eb SW |
742 | } |
743 | ||
744 | dout("done with %llx %p, invalidated=%d, %p %p\n", realm->ino, | |
745 | realm, invalidate, p, e); | |
746 | ||
963b61eb | 747 | /* invalidate when we reach the _end_ (root) of the trace */ |
982d6011 | 748 | if (invalidate && p >= e) |
963b61eb SW |
749 | rebuild_snap_realms(realm); |
750 | ||
982d6011 YZ |
751 | if (!first_realm) |
752 | first_realm = realm; | |
753 | else | |
754 | ceph_put_snap_realm(mdsc, realm); | |
755 | ||
756 | if (p < e) | |
757 | goto more; | |
758 | ||
ae00d4f3 SW |
759 | /* |
760 | * queue cap snaps _after_ we've built the new snap contexts, | |
761 | * so that i_head_snapc can be set appropriately. | |
762 | */ | |
e8e1ba96 SW |
763 | while (!list_empty(&dirty_realms)) { |
764 | realm = list_first_entry(&dirty_realms, struct ceph_snap_realm, | |
765 | dirty_item); | |
ae00d4f3 SW |
766 | queue_realm_cap_snaps(realm); |
767 | } | |
768 | ||
982d6011 YZ |
769 | if (realm_ret) |
770 | *realm_ret = first_realm; | |
771 | else | |
772 | ceph_put_snap_realm(mdsc, first_realm); | |
773 | ||
963b61eb SW |
774 | __cleanup_empty_realms(mdsc); |
775 | return 0; | |
776 | ||
777 | bad: | |
778 | err = -EINVAL; | |
779 | fail: | |
982d6011 YZ |
780 | if (realm && !IS_ERR(realm)) |
781 | ceph_put_snap_realm(mdsc, realm); | |
782 | if (first_realm) | |
783 | ceph_put_snap_realm(mdsc, first_realm); | |
963b61eb SW |
784 | pr_err("update_snap_trace error %d\n", err); |
785 | return err; | |
786 | } | |
787 | ||
788 | ||
789 | /* | |
790 | * Send any cap_snaps that are queued for flush. Try to carry | |
791 | * s_mutex across multiple snap flushes to avoid locking overhead. | |
792 | * | |
793 | * Caller holds no locks. | |
794 | */ | |
795 | static void flush_snaps(struct ceph_mds_client *mdsc) | |
796 | { | |
797 | struct ceph_inode_info *ci; | |
798 | struct inode *inode; | |
799 | struct ceph_mds_session *session = NULL; | |
800 | ||
801 | dout("flush_snaps\n"); | |
802 | spin_lock(&mdsc->snap_flush_lock); | |
803 | while (!list_empty(&mdsc->snap_flush_list)) { | |
804 | ci = list_first_entry(&mdsc->snap_flush_list, | |
805 | struct ceph_inode_info, i_snap_flush_item); | |
806 | inode = &ci->vfs_inode; | |
70b666c3 | 807 | ihold(inode); |
963b61eb | 808 | spin_unlock(&mdsc->snap_flush_lock); |
be655596 | 809 | spin_lock(&ci->i_ceph_lock); |
e835124c | 810 | __ceph_flush_snaps(ci, &session, 0); |
be655596 | 811 | spin_unlock(&ci->i_ceph_lock); |
963b61eb SW |
812 | iput(inode); |
813 | spin_lock(&mdsc->snap_flush_lock); | |
814 | } | |
815 | spin_unlock(&mdsc->snap_flush_lock); | |
816 | ||
817 | if (session) { | |
818 | mutex_unlock(&session->s_mutex); | |
819 | ceph_put_mds_session(session); | |
820 | } | |
821 | dout("flush_snaps done\n"); | |
822 | } | |
823 | ||
824 | ||
825 | /* | |
826 | * Handle a snap notification from the MDS. | |
827 | * | |
828 | * This can take two basic forms: the simplest is just a snap creation | |
829 | * or deletion notification on an existing realm. This should update the | |
830 | * realm and its children. | |
831 | * | |
832 | * The more difficult case is realm creation, due to snap creation at a | |
833 | * new point in the file hierarchy, or due to a rename that moves a file or | |
834 | * directory into another realm. | |
835 | */ | |
836 | void ceph_handle_snap(struct ceph_mds_client *mdsc, | |
2600d2dd | 837 | struct ceph_mds_session *session, |
963b61eb SW |
838 | struct ceph_msg *msg) |
839 | { | |
3d14c5d2 | 840 | struct super_block *sb = mdsc->fsc->sb; |
2600d2dd | 841 | int mds = session->s_mds; |
963b61eb SW |
842 | u64 split; |
843 | int op; | |
844 | int trace_len; | |
845 | struct ceph_snap_realm *realm = NULL; | |
846 | void *p = msg->front.iov_base; | |
847 | void *e = p + msg->front.iov_len; | |
848 | struct ceph_mds_snap_head *h; | |
849 | int num_split_inos, num_split_realms; | |
850 | __le64 *split_inos = NULL, *split_realms = NULL; | |
851 | int i; | |
852 | int locked_rwsem = 0; | |
853 | ||
963b61eb SW |
854 | /* decode */ |
855 | if (msg->front.iov_len < sizeof(*h)) | |
856 | goto bad; | |
857 | h = p; | |
858 | op = le32_to_cpu(h->op); | |
859 | split = le64_to_cpu(h->split); /* non-zero if we are splitting an | |
860 | * existing realm */ | |
861 | num_split_inos = le32_to_cpu(h->num_split_inos); | |
862 | num_split_realms = le32_to_cpu(h->num_split_realms); | |
863 | trace_len = le32_to_cpu(h->trace_len); | |
864 | p += sizeof(*h); | |
865 | ||
866 | dout("handle_snap from mds%d op %s split %llx tracelen %d\n", mds, | |
867 | ceph_snap_op_name(op), split, trace_len); | |
868 | ||
963b61eb SW |
869 | mutex_lock(&session->s_mutex); |
870 | session->s_seq++; | |
871 | mutex_unlock(&session->s_mutex); | |
872 | ||
873 | down_write(&mdsc->snap_rwsem); | |
874 | locked_rwsem = 1; | |
875 | ||
876 | if (op == CEPH_SNAP_OP_SPLIT) { | |
877 | struct ceph_mds_snap_realm *ri; | |
878 | ||
879 | /* | |
880 | * A "split" breaks part of an existing realm off into | |
881 | * a new realm. The MDS provides a list of inodes | |
882 | * (with caps) and child realms that belong to the new | |
883 | * child. | |
884 | */ | |
885 | split_inos = p; | |
886 | p += sizeof(u64) * num_split_inos; | |
887 | split_realms = p; | |
888 | p += sizeof(u64) * num_split_realms; | |
889 | ceph_decode_need(&p, e, sizeof(*ri), bad); | |
890 | /* we will peek at realm info here, but will _not_ | |
891 | * advance p, as the realm update will occur below in | |
892 | * ceph_update_snap_trace. */ | |
893 | ri = p; | |
894 | ||
895 | realm = ceph_lookup_snap_realm(mdsc, split); | |
963b61eb SW |
896 | if (!realm) { |
897 | realm = ceph_create_snap_realm(mdsc, split); | |
898 | if (IS_ERR(realm)) | |
899 | goto out; | |
900 | } | |
963b61eb SW |
901 | |
902 | dout("splitting snap_realm %llx %p\n", realm->ino, realm); | |
903 | for (i = 0; i < num_split_inos; i++) { | |
904 | struct ceph_vino vino = { | |
905 | .ino = le64_to_cpu(split_inos[i]), | |
906 | .snap = CEPH_NOSNAP, | |
907 | }; | |
908 | struct inode *inode = ceph_find_inode(sb, vino); | |
909 | struct ceph_inode_info *ci; | |
ae00d4f3 | 910 | struct ceph_snap_realm *oldrealm; |
963b61eb SW |
911 | |
912 | if (!inode) | |
913 | continue; | |
914 | ci = ceph_inode(inode); | |
915 | ||
be655596 | 916 | spin_lock(&ci->i_ceph_lock); |
963b61eb SW |
917 | if (!ci->i_snap_realm) |
918 | goto skip_inode; | |
919 | /* | |
920 | * If this inode belongs to a realm that was | |
921 | * created after our new realm, we experienced | |
922 | * a race (due to another split notifications | |
923 | * arriving from a different MDS). So skip | |
924 | * this inode. | |
925 | */ | |
926 | if (ci->i_snap_realm->created > | |
927 | le64_to_cpu(ri->created)) { | |
928 | dout(" leaving %p in newer realm %llx %p\n", | |
929 | inode, ci->i_snap_realm->ino, | |
930 | ci->i_snap_realm); | |
931 | goto skip_inode; | |
932 | } | |
933 | dout(" will move %p to split realm %llx %p\n", | |
934 | inode, realm->ino, realm); | |
935 | /* | |
ae00d4f3 | 936 | * Move the inode to the new realm |
963b61eb | 937 | */ |
052bb34a | 938 | spin_lock(&realm->inodes_with_caps_lock); |
963b61eb | 939 | list_del_init(&ci->i_snap_realm_item); |
ae00d4f3 SW |
940 | list_add(&ci->i_snap_realm_item, |
941 | &realm->inodes_with_caps); | |
942 | oldrealm = ci->i_snap_realm; | |
943 | ci->i_snap_realm = realm; | |
052bb34a | 944 | spin_unlock(&realm->inodes_with_caps_lock); |
be655596 | 945 | spin_unlock(&ci->i_ceph_lock); |
963b61eb | 946 | |
ae00d4f3 SW |
947 | ceph_get_snap_realm(mdsc, realm); |
948 | ceph_put_snap_realm(mdsc, oldrealm); | |
963b61eb SW |
949 | |
950 | iput(inode); | |
951 | continue; | |
952 | ||
953 | skip_inode: | |
be655596 | 954 | spin_unlock(&ci->i_ceph_lock); |
963b61eb SW |
955 | iput(inode); |
956 | } | |
957 | ||
958 | /* we may have taken some of the old realm's children. */ | |
959 | for (i = 0; i < num_split_realms; i++) { | |
960 | struct ceph_snap_realm *child = | |
982d6011 | 961 | __lookup_snap_realm(mdsc, |
963b61eb | 962 | le64_to_cpu(split_realms[i])); |
963b61eb SW |
963 | if (!child) |
964 | continue; | |
965 | adjust_snap_realm_parent(mdsc, child, realm->ino); | |
966 | } | |
967 | } | |
968 | ||
969 | /* | |
970 | * update using the provided snap trace. if we are deleting a | |
971 | * snap, we can avoid queueing cap_snaps. | |
972 | */ | |
973 | ceph_update_snap_trace(mdsc, p, e, | |
982d6011 | 974 | op == CEPH_SNAP_OP_DESTROY, NULL); |
963b61eb | 975 | |
ae00d4f3 | 976 | if (op == CEPH_SNAP_OP_SPLIT) |
963b61eb SW |
977 | /* we took a reference when we created the realm, above */ |
978 | ceph_put_snap_realm(mdsc, realm); | |
963b61eb SW |
979 | |
980 | __cleanup_empty_realms(mdsc); | |
981 | ||
982 | up_write(&mdsc->snap_rwsem); | |
983 | ||
984 | flush_snaps(mdsc); | |
985 | return; | |
986 | ||
987 | bad: | |
988 | pr_err("corrupt snap message from mds%d\n", mds); | |
9ec7cab1 | 989 | ceph_msg_dump(msg); |
963b61eb SW |
990 | out: |
991 | if (locked_rwsem) | |
992 | up_write(&mdsc->snap_rwsem); | |
993 | return; | |
994 | } | |
995 | ||
97c85a82 YZ |
996 | int __init ceph_snap_init(void) |
997 | { | |
7b06a826 YZ |
998 | ceph_empty_snapc = ceph_create_snap_context(0, GFP_NOFS); |
999 | if (!ceph_empty_snapc) | |
97c85a82 | 1000 | return -ENOMEM; |
7b06a826 | 1001 | ceph_empty_snapc->seq = 1; |
97c85a82 YZ |
1002 | return 0; |
1003 | } | |
963b61eb | 1004 | |
97c85a82 YZ |
1005 | void ceph_snap_exit(void) |
1006 | { | |
7b06a826 | 1007 | ceph_put_snap_context(ceph_empty_snapc); |
97c85a82 | 1008 | } |