nilfs2: fix gc failure on volumes keeping numerous snapshots
[deliverable/linux.git] / fs / nilfs2 / cpfile.c
1 /*
2 * cpfile.c - NILFS checkpoint file.
3 *
4 * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 * Written by Koji Sato <koji@osrg.net>.
21 */
22
23 #include <linux/kernel.h>
24 #include <linux/fs.h>
25 #include <linux/string.h>
26 #include <linux/buffer_head.h>
27 #include <linux/errno.h>
28 #include <linux/nilfs2_fs.h>
29 #include "mdt.h"
30 #include "cpfile.h"
31
32
33 static inline unsigned long
34 nilfs_cpfile_checkpoints_per_block(const struct inode *cpfile)
35 {
36 return NILFS_MDT(cpfile)->mi_entries_per_block;
37 }
38
39 /* block number from the beginning of the file */
40 static unsigned long
41 nilfs_cpfile_get_blkoff(const struct inode *cpfile, __u64 cno)
42 {
43 __u64 tcno;
44
45 BUG_ON(cno == 0); /* checkpoint number 0 is invalid */
46 tcno = cno + NILFS_MDT(cpfile)->mi_first_entry_offset - 1;
47 do_div(tcno, nilfs_cpfile_checkpoints_per_block(cpfile));
48 return (unsigned long)tcno;
49 }
50
51 /* offset in block */
52 static unsigned long
53 nilfs_cpfile_get_offset(const struct inode *cpfile, __u64 cno)
54 {
55 __u64 tcno = cno + NILFS_MDT(cpfile)->mi_first_entry_offset - 1;
56 return do_div(tcno, nilfs_cpfile_checkpoints_per_block(cpfile));
57 }
58
59 static unsigned long
60 nilfs_cpfile_checkpoints_in_block(const struct inode *cpfile,
61 __u64 curr,
62 __u64 max)
63 {
64 return min_t(__u64,
65 nilfs_cpfile_checkpoints_per_block(cpfile) -
66 nilfs_cpfile_get_offset(cpfile, curr),
67 max - curr);
68 }
69
70 static inline int nilfs_cpfile_is_in_first(const struct inode *cpfile,
71 __u64 cno)
72 {
73 return nilfs_cpfile_get_blkoff(cpfile, cno) == 0;
74 }
75
76 static unsigned int
77 nilfs_cpfile_block_add_valid_checkpoints(const struct inode *cpfile,
78 struct buffer_head *bh,
79 void *kaddr,
80 unsigned int n)
81 {
82 struct nilfs_checkpoint *cp = kaddr + bh_offset(bh);
83 unsigned int count;
84
85 count = le32_to_cpu(cp->cp_checkpoints_count) + n;
86 cp->cp_checkpoints_count = cpu_to_le32(count);
87 return count;
88 }
89
90 static unsigned int
91 nilfs_cpfile_block_sub_valid_checkpoints(const struct inode *cpfile,
92 struct buffer_head *bh,
93 void *kaddr,
94 unsigned int n)
95 {
96 struct nilfs_checkpoint *cp = kaddr + bh_offset(bh);
97 unsigned int count;
98
99 BUG_ON(le32_to_cpu(cp->cp_checkpoints_count) < n);
100 count = le32_to_cpu(cp->cp_checkpoints_count) - n;
101 cp->cp_checkpoints_count = cpu_to_le32(count);
102 return count;
103 }
104
105 static inline struct nilfs_cpfile_header *
106 nilfs_cpfile_block_get_header(const struct inode *cpfile,
107 struct buffer_head *bh,
108 void *kaddr)
109 {
110 return kaddr + bh_offset(bh);
111 }
112
113 static struct nilfs_checkpoint *
114 nilfs_cpfile_block_get_checkpoint(const struct inode *cpfile, __u64 cno,
115 struct buffer_head *bh,
116 void *kaddr)
117 {
118 return kaddr + bh_offset(bh) + nilfs_cpfile_get_offset(cpfile, cno) *
119 NILFS_MDT(cpfile)->mi_entry_size;
120 }
121
122 static void nilfs_cpfile_block_init(struct inode *cpfile,
123 struct buffer_head *bh,
124 void *kaddr)
125 {
126 struct nilfs_checkpoint *cp = kaddr + bh_offset(bh);
127 size_t cpsz = NILFS_MDT(cpfile)->mi_entry_size;
128 int n = nilfs_cpfile_checkpoints_per_block(cpfile);
129
130 while (n-- > 0) {
131 nilfs_checkpoint_set_invalid(cp);
132 cp = (void *)cp + cpsz;
133 }
134 }
135
136 static inline int nilfs_cpfile_get_header_block(struct inode *cpfile,
137 struct buffer_head **bhp)
138 {
139 return nilfs_mdt_get_block(cpfile, 0, 0, NULL, bhp);
140 }
141
142 static inline int nilfs_cpfile_get_checkpoint_block(struct inode *cpfile,
143 __u64 cno,
144 int create,
145 struct buffer_head **bhp)
146 {
147 return nilfs_mdt_get_block(cpfile,
148 nilfs_cpfile_get_blkoff(cpfile, cno),
149 create, nilfs_cpfile_block_init, bhp);
150 }
151
152 static inline int nilfs_cpfile_delete_checkpoint_block(struct inode *cpfile,
153 __u64 cno)
154 {
155 return nilfs_mdt_delete_block(cpfile,
156 nilfs_cpfile_get_blkoff(cpfile, cno));
157 }
158
159 /**
160 * nilfs_cpfile_get_checkpoint - get a checkpoint
161 * @cpfile: inode of checkpoint file
162 * @cno: checkpoint number
163 * @create: create flag
164 * @cpp: pointer to a checkpoint
165 * @bhp: pointer to a buffer head
166 *
167 * Description: nilfs_cpfile_get_checkpoint() acquires the checkpoint
168 * specified by @cno. A new checkpoint will be created if @cno is the current
169 * checkpoint number and @create is nonzero.
170 *
171 * Return Value: On success, 0 is returned, and the checkpoint and the
172 * buffer head of the buffer on which the checkpoint is located are stored in
173 * the place pointed by @cpp and @bhp, respectively. On error, one of the
174 * following negative error codes is returned.
175 *
176 * %-EIO - I/O error.
177 *
178 * %-ENOMEM - Insufficient amount of memory available.
179 *
180 * %-ENOENT - No such checkpoint.
181 */
182 int nilfs_cpfile_get_checkpoint(struct inode *cpfile,
183 __u64 cno,
184 int create,
185 struct nilfs_checkpoint **cpp,
186 struct buffer_head **bhp)
187 {
188 struct buffer_head *header_bh, *cp_bh;
189 struct nilfs_cpfile_header *header;
190 struct nilfs_checkpoint *cp;
191 void *kaddr;
192 int ret;
193
194 BUG_ON(cno < 1 || cno > nilfs_mdt_cno(cpfile) ||
195 (cno < nilfs_mdt_cno(cpfile) && create));
196
197 down_write(&NILFS_MDT(cpfile)->mi_sem);
198
199 ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);
200 if (ret < 0)
201 goto out_sem;
202 ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, create, &cp_bh);
203 if (ret < 0)
204 goto out_header;
205 kaddr = kmap(cp_bh->b_page);
206 cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
207 if (nilfs_checkpoint_invalid(cp)) {
208 if (!create) {
209 kunmap(cp_bh->b_page);
210 brelse(cp_bh);
211 ret = -ENOENT;
212 goto out_header;
213 }
214 /* a newly-created checkpoint */
215 nilfs_checkpoint_clear_invalid(cp);
216 if (!nilfs_cpfile_is_in_first(cpfile, cno))
217 nilfs_cpfile_block_add_valid_checkpoints(cpfile, cp_bh,
218 kaddr, 1);
219 nilfs_mdt_mark_buffer_dirty(cp_bh);
220
221 kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
222 header = nilfs_cpfile_block_get_header(cpfile, header_bh,
223 kaddr);
224 le64_add_cpu(&header->ch_ncheckpoints, 1);
225 kunmap_atomic(kaddr, KM_USER0);
226 nilfs_mdt_mark_buffer_dirty(header_bh);
227 nilfs_mdt_mark_dirty(cpfile);
228 }
229
230 if (cpp != NULL)
231 *cpp = cp;
232 *bhp = cp_bh;
233
234 out_header:
235 brelse(header_bh);
236
237 out_sem:
238 up_write(&NILFS_MDT(cpfile)->mi_sem);
239 return ret;
240 }
241
242 /**
243 * nilfs_cpfile_put_checkpoint - put a checkpoint
244 * @cpfile: inode of checkpoint file
245 * @cno: checkpoint number
246 * @bh: buffer head
247 *
248 * Description: nilfs_cpfile_put_checkpoint() releases the checkpoint
249 * specified by @cno. @bh must be the buffer head which has been returned by
250 * a previous call to nilfs_cpfile_get_checkpoint() with @cno.
251 */
252 void nilfs_cpfile_put_checkpoint(struct inode *cpfile, __u64 cno,
253 struct buffer_head *bh)
254 {
255 kunmap(bh->b_page);
256 brelse(bh);
257 }
258
259 /**
260 * nilfs_cpfile_delete_checkpoints - delete checkpoints
261 * @cpfile: inode of checkpoint file
262 * @start: start checkpoint number
263 * @end: end checkpoint numer
264 *
265 * Description: nilfs_cpfile_delete_checkpoints() deletes the checkpoints in
266 * the period from @start to @end, excluding @end itself. The checkpoints
267 * which have been already deleted are ignored.
268 *
269 * Return Value: On success, 0 is returned. On error, one of the following
270 * negative error codes is returned.
271 *
272 * %-EIO - I/O error.
273 *
274 * %-ENOMEM - Insufficient amount of memory available.
275 *
276 * %-EINVAL - invalid checkpoints.
277 */
278 int nilfs_cpfile_delete_checkpoints(struct inode *cpfile,
279 __u64 start,
280 __u64 end)
281 {
282 struct buffer_head *header_bh, *cp_bh;
283 struct nilfs_cpfile_header *header;
284 struct nilfs_checkpoint *cp;
285 size_t cpsz = NILFS_MDT(cpfile)->mi_entry_size;
286 __u64 cno;
287 void *kaddr;
288 unsigned long tnicps;
289 int ret, ncps, nicps, count, i;
290
291 if ((start == 0) || (start > end)) {
292 printk(KERN_CRIT "%s: start = %llu, end = %llu\n",
293 __func__,
294 (unsigned long long)start,
295 (unsigned long long)end);
296 BUG();
297 }
298
299 /* cannot delete the latest checkpoint */
300 if (start == nilfs_mdt_cno(cpfile) - 1)
301 return -EPERM;
302
303 down_write(&NILFS_MDT(cpfile)->mi_sem);
304
305 ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);
306 if (ret < 0)
307 goto out_sem;
308 tnicps = 0;
309
310 for (cno = start; cno < end; cno += ncps) {
311 ncps = nilfs_cpfile_checkpoints_in_block(cpfile, cno, end);
312 ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &cp_bh);
313 if (ret < 0) {
314 if (ret != -ENOENT)
315 goto out_sem;
316 /* skip hole */
317 ret = 0;
318 continue;
319 }
320
321 kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
322 cp = nilfs_cpfile_block_get_checkpoint(
323 cpfile, cno, cp_bh, kaddr);
324 nicps = 0;
325 for (i = 0; i < ncps; i++, cp = (void *)cp + cpsz) {
326 BUG_ON(nilfs_checkpoint_snapshot(cp));
327 if (!nilfs_checkpoint_invalid(cp)) {
328 nilfs_checkpoint_set_invalid(cp);
329 nicps++;
330 }
331 }
332 if (nicps > 0) {
333 tnicps += nicps;
334 nilfs_mdt_mark_buffer_dirty(cp_bh);
335 nilfs_mdt_mark_dirty(cpfile);
336 if (!nilfs_cpfile_is_in_first(cpfile, cno) &&
337 (count = nilfs_cpfile_block_sub_valid_checkpoints(
338 cpfile, cp_bh, kaddr, nicps)) == 0) {
339 /* make hole */
340 kunmap_atomic(kaddr, KM_USER0);
341 brelse(cp_bh);
342 ret = nilfs_cpfile_delete_checkpoint_block(
343 cpfile, cno);
344 if (ret == 0)
345 continue;
346 printk(KERN_ERR "%s: cannot delete block\n",
347 __func__);
348 goto out_sem;
349 }
350 }
351
352 kunmap_atomic(kaddr, KM_USER0);
353 brelse(cp_bh);
354 }
355
356 if (tnicps > 0) {
357 kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
358 header = nilfs_cpfile_block_get_header(cpfile, header_bh,
359 kaddr);
360 le64_add_cpu(&header->ch_ncheckpoints, -(u64)tnicps);
361 nilfs_mdt_mark_buffer_dirty(header_bh);
362 nilfs_mdt_mark_dirty(cpfile);
363 kunmap_atomic(kaddr, KM_USER0);
364 }
365 brelse(header_bh);
366
367 out_sem:
368 up_write(&NILFS_MDT(cpfile)->mi_sem);
369 return ret;
370 }
371
372 static void nilfs_cpfile_checkpoint_to_cpinfo(struct inode *cpfile,
373 struct nilfs_checkpoint *cp,
374 struct nilfs_cpinfo *ci)
375 {
376 ci->ci_flags = le32_to_cpu(cp->cp_flags);
377 ci->ci_cno = le64_to_cpu(cp->cp_cno);
378 ci->ci_create = le64_to_cpu(cp->cp_create);
379 ci->ci_nblk_inc = le64_to_cpu(cp->cp_nblk_inc);
380 ci->ci_inodes_count = le64_to_cpu(cp->cp_inodes_count);
381 ci->ci_blocks_count = le64_to_cpu(cp->cp_blocks_count);
382 ci->ci_next = le64_to_cpu(cp->cp_snapshot_list.ssl_next);
383 }
384
385 static ssize_t nilfs_cpfile_do_get_cpinfo(struct inode *cpfile, __u64 cno,
386 struct nilfs_cpinfo *ci, size_t nci)
387 {
388 struct nilfs_checkpoint *cp;
389 struct buffer_head *bh;
390 size_t cpsz = NILFS_MDT(cpfile)->mi_entry_size;
391 __u64 cur_cno = nilfs_mdt_cno(cpfile);
392 void *kaddr;
393 int n, ret;
394 int ncps, i;
395
396 down_read(&NILFS_MDT(cpfile)->mi_sem);
397
398 for (n = 0; cno < cur_cno && n < nci; cno += ncps) {
399 ncps = nilfs_cpfile_checkpoints_in_block(cpfile, cno, cur_cno);
400 ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &bh);
401 if (ret < 0) {
402 if (ret != -ENOENT)
403 goto out;
404 continue; /* skip hole */
405 }
406
407 kaddr = kmap_atomic(bh->b_page, KM_USER0);
408 cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, bh, kaddr);
409 for (i = 0; i < ncps && n < nci; i++, cp = (void *)cp + cpsz) {
410 if (!nilfs_checkpoint_invalid(cp))
411 nilfs_cpfile_checkpoint_to_cpinfo(
412 cpfile, cp, &ci[n++]);
413 }
414 kunmap_atomic(kaddr, KM_USER0);
415 brelse(bh);
416 }
417
418 ret = n;
419
420 out:
421 up_read(&NILFS_MDT(cpfile)->mi_sem);
422 return ret;
423 }
424
425 static ssize_t nilfs_cpfile_do_get_ssinfo(struct inode *cpfile, __u64 *cnop,
426 struct nilfs_cpinfo *ci, size_t nci)
427 {
428 struct buffer_head *bh;
429 struct nilfs_cpfile_header *header;
430 struct nilfs_checkpoint *cp;
431 __u64 curr = *cnop, next;
432 unsigned long curr_blkoff, next_blkoff;
433 void *kaddr;
434 int n, ret;
435
436 down_read(&NILFS_MDT(cpfile)->mi_sem);
437
438 if (curr == 0) {
439 ret = nilfs_cpfile_get_header_block(cpfile, &bh);
440 if (ret < 0)
441 goto out;
442 kaddr = kmap_atomic(bh->b_page, KM_USER0);
443 header = nilfs_cpfile_block_get_header(cpfile, bh, kaddr);
444 curr = le64_to_cpu(header->ch_snapshot_list.ssl_next);
445 kunmap_atomic(kaddr, KM_USER0);
446 brelse(bh);
447 if (curr == 0) {
448 ret = 0;
449 goto out;
450 }
451 } else if (unlikely(curr == ~(__u64)0)) {
452 ret = 0;
453 goto out;
454 }
455
456 curr_blkoff = nilfs_cpfile_get_blkoff(cpfile, curr);
457 ret = nilfs_cpfile_get_checkpoint_block(cpfile, curr, 0, &bh);
458 if (ret < 0)
459 goto out;
460 kaddr = kmap_atomic(bh->b_page, KM_USER0);
461 for (n = 0; n < nci; n++) {
462 cp = nilfs_cpfile_block_get_checkpoint(
463 cpfile, curr, bh, kaddr);
464 nilfs_cpfile_checkpoint_to_cpinfo(cpfile, cp, &ci[n]);
465 next = le64_to_cpu(cp->cp_snapshot_list.ssl_next);
466 if (next == 0) {
467 curr = ~(__u64)0; /* Terminator */
468 n++;
469 break;
470 }
471 next_blkoff = nilfs_cpfile_get_blkoff(cpfile, next);
472 if (curr_blkoff != next_blkoff) {
473 kunmap_atomic(kaddr, KM_USER0);
474 brelse(bh);
475 ret = nilfs_cpfile_get_checkpoint_block(cpfile, next,
476 0, &bh);
477 if (ret < 0)
478 goto out;
479 kaddr = kmap_atomic(bh->b_page, KM_USER0);
480 }
481 curr = next;
482 curr_blkoff = next_blkoff;
483 }
484 kunmap_atomic(kaddr, KM_USER0);
485 brelse(bh);
486 *cnop = curr;
487 ret = n;
488
489 out:
490 up_read(&NILFS_MDT(cpfile)->mi_sem);
491 return ret;
492 }
493
494 /**
495 * nilfs_cpfile_get_cpinfo -
496 * @cpfile:
497 * @cno:
498 * @ci:
499 * @nci:
500 */
501
502 ssize_t nilfs_cpfile_get_cpinfo(struct inode *cpfile, __u64 *cnop, int mode,
503 struct nilfs_cpinfo *ci, size_t nci)
504 {
505 switch (mode) {
506 case NILFS_CHECKPOINT:
507 return nilfs_cpfile_do_get_cpinfo(cpfile, *cnop, ci, nci);
508 case NILFS_SNAPSHOT:
509 return nilfs_cpfile_do_get_ssinfo(cpfile, cnop, ci, nci);
510 default:
511 return -EINVAL;
512 }
513 }
514
515 /**
516 * nilfs_cpfile_delete_checkpoint -
517 * @cpfile:
518 * @cno:
519 */
520 int nilfs_cpfile_delete_checkpoint(struct inode *cpfile, __u64 cno)
521 {
522 struct nilfs_cpinfo ci;
523 ssize_t nci;
524 int ret;
525
526 /* checkpoint number 0 is invalid */
527 if (cno == 0)
528 return -ENOENT;
529 nci = nilfs_cpfile_do_get_cpinfo(cpfile, cno, &ci, 1);
530 if (nci < 0)
531 return nci;
532 else if (nci == 0 || ci.ci_cno != cno)
533 return -ENOENT;
534
535 /* cannot delete the latest checkpoint nor snapshots */
536 ret = nilfs_cpinfo_snapshot(&ci);
537 if (ret < 0)
538 return ret;
539 else if (ret > 0 || cno == nilfs_mdt_cno(cpfile) - 1)
540 return -EPERM;
541
542 return nilfs_cpfile_delete_checkpoints(cpfile, cno, cno + 1);
543 }
544
545 static struct nilfs_snapshot_list *
546 nilfs_cpfile_block_get_snapshot_list(const struct inode *cpfile,
547 __u64 cno,
548 struct buffer_head *bh,
549 void *kaddr)
550 {
551 struct nilfs_cpfile_header *header;
552 struct nilfs_checkpoint *cp;
553 struct nilfs_snapshot_list *list;
554
555 if (cno != 0) {
556 cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, bh, kaddr);
557 list = &cp->cp_snapshot_list;
558 } else {
559 header = nilfs_cpfile_block_get_header(cpfile, bh, kaddr);
560 list = &header->ch_snapshot_list;
561 }
562 return list;
563 }
564
565 static int nilfs_cpfile_set_snapshot(struct inode *cpfile, __u64 cno)
566 {
567 struct buffer_head *header_bh, *curr_bh, *prev_bh, *cp_bh;
568 struct nilfs_cpfile_header *header;
569 struct nilfs_checkpoint *cp;
570 struct nilfs_snapshot_list *list;
571 __u64 curr, prev;
572 unsigned long curr_blkoff, prev_blkoff;
573 void *kaddr;
574 int ret;
575
576 down_write(&NILFS_MDT(cpfile)->mi_sem);
577
578 ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &cp_bh);
579 if (ret < 0)
580 goto out_sem;
581 kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
582 cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
583 if (nilfs_checkpoint_invalid(cp)) {
584 ret = -ENOENT;
585 kunmap_atomic(kaddr, KM_USER0);
586 goto out_cp;
587 }
588 if (nilfs_checkpoint_snapshot(cp)) {
589 ret = 0;
590 kunmap_atomic(kaddr, KM_USER0);
591 goto out_cp;
592 }
593 kunmap_atomic(kaddr, KM_USER0);
594
595 ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);
596 if (ret < 0)
597 goto out_cp;
598 kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
599 header = nilfs_cpfile_block_get_header(cpfile, header_bh, kaddr);
600 list = &header->ch_snapshot_list;
601 curr_bh = header_bh;
602 get_bh(curr_bh);
603 curr = 0;
604 curr_blkoff = 0;
605 prev = le64_to_cpu(list->ssl_prev);
606 while (prev > cno) {
607 prev_blkoff = nilfs_cpfile_get_blkoff(cpfile, prev);
608 curr = prev;
609 if (curr_blkoff != prev_blkoff) {
610 kunmap_atomic(kaddr, KM_USER0);
611 brelse(curr_bh);
612 ret = nilfs_cpfile_get_checkpoint_block(cpfile, curr,
613 0, &curr_bh);
614 if (ret < 0)
615 goto out_header;
616 kaddr = kmap_atomic(curr_bh->b_page, KM_USER0);
617 }
618 curr_blkoff = prev_blkoff;
619 cp = nilfs_cpfile_block_get_checkpoint(
620 cpfile, curr, curr_bh, kaddr);
621 list = &cp->cp_snapshot_list;
622 prev = le64_to_cpu(list->ssl_prev);
623 }
624 kunmap_atomic(kaddr, KM_USER0);
625
626 if (prev != 0) {
627 ret = nilfs_cpfile_get_checkpoint_block(cpfile, prev, 0,
628 &prev_bh);
629 if (ret < 0)
630 goto out_curr;
631 } else {
632 prev_bh = header_bh;
633 get_bh(prev_bh);
634 }
635
636 kaddr = kmap_atomic(curr_bh->b_page, KM_USER0);
637 list = nilfs_cpfile_block_get_snapshot_list(
638 cpfile, curr, curr_bh, kaddr);
639 list->ssl_prev = cpu_to_le64(cno);
640 kunmap_atomic(kaddr, KM_USER0);
641
642 kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
643 cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
644 cp->cp_snapshot_list.ssl_next = cpu_to_le64(curr);
645 cp->cp_snapshot_list.ssl_prev = cpu_to_le64(prev);
646 nilfs_checkpoint_set_snapshot(cp);
647 kunmap_atomic(kaddr, KM_USER0);
648
649 kaddr = kmap_atomic(prev_bh->b_page, KM_USER0);
650 list = nilfs_cpfile_block_get_snapshot_list(
651 cpfile, prev, prev_bh, kaddr);
652 list->ssl_next = cpu_to_le64(cno);
653 kunmap_atomic(kaddr, KM_USER0);
654
655 kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
656 header = nilfs_cpfile_block_get_header(cpfile, header_bh, kaddr);
657 le64_add_cpu(&header->ch_nsnapshots, 1);
658 kunmap_atomic(kaddr, KM_USER0);
659
660 nilfs_mdt_mark_buffer_dirty(prev_bh);
661 nilfs_mdt_mark_buffer_dirty(curr_bh);
662 nilfs_mdt_mark_buffer_dirty(cp_bh);
663 nilfs_mdt_mark_buffer_dirty(header_bh);
664 nilfs_mdt_mark_dirty(cpfile);
665
666 brelse(prev_bh);
667
668 out_curr:
669 brelse(curr_bh);
670
671 out_header:
672 brelse(header_bh);
673
674 out_cp:
675 brelse(cp_bh);
676
677 out_sem:
678 up_write(&NILFS_MDT(cpfile)->mi_sem);
679 return ret;
680 }
681
682 static int nilfs_cpfile_clear_snapshot(struct inode *cpfile, __u64 cno)
683 {
684 struct buffer_head *header_bh, *next_bh, *prev_bh, *cp_bh;
685 struct nilfs_cpfile_header *header;
686 struct nilfs_checkpoint *cp;
687 struct nilfs_snapshot_list *list;
688 __u64 next, prev;
689 void *kaddr;
690 int ret;
691
692 down_write(&NILFS_MDT(cpfile)->mi_sem);
693
694 ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &cp_bh);
695 if (ret < 0)
696 goto out_sem;
697 kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
698 cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
699 if (nilfs_checkpoint_invalid(cp)) {
700 ret = -ENOENT;
701 kunmap_atomic(kaddr, KM_USER0);
702 goto out_cp;
703 }
704 if (!nilfs_checkpoint_snapshot(cp)) {
705 ret = 0;
706 kunmap_atomic(kaddr, KM_USER0);
707 goto out_cp;
708 }
709
710 list = &cp->cp_snapshot_list;
711 next = le64_to_cpu(list->ssl_next);
712 prev = le64_to_cpu(list->ssl_prev);
713 kunmap_atomic(kaddr, KM_USER0);
714
715 ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);
716 if (ret < 0)
717 goto out_cp;
718 if (next != 0) {
719 ret = nilfs_cpfile_get_checkpoint_block(cpfile, next, 0,
720 &next_bh);
721 if (ret < 0)
722 goto out_header;
723 } else {
724 next_bh = header_bh;
725 get_bh(next_bh);
726 }
727 if (prev != 0) {
728 ret = nilfs_cpfile_get_checkpoint_block(cpfile, prev, 0,
729 &prev_bh);
730 if (ret < 0)
731 goto out_next;
732 } else {
733 prev_bh = header_bh;
734 get_bh(prev_bh);
735 }
736
737 kaddr = kmap_atomic(next_bh->b_page, KM_USER0);
738 list = nilfs_cpfile_block_get_snapshot_list(
739 cpfile, next, next_bh, kaddr);
740 list->ssl_prev = cpu_to_le64(prev);
741 kunmap_atomic(kaddr, KM_USER0);
742
743 kaddr = kmap_atomic(prev_bh->b_page, KM_USER0);
744 list = nilfs_cpfile_block_get_snapshot_list(
745 cpfile, prev, prev_bh, kaddr);
746 list->ssl_next = cpu_to_le64(next);
747 kunmap_atomic(kaddr, KM_USER0);
748
749 kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
750 cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
751 cp->cp_snapshot_list.ssl_next = cpu_to_le64(0);
752 cp->cp_snapshot_list.ssl_prev = cpu_to_le64(0);
753 nilfs_checkpoint_clear_snapshot(cp);
754 kunmap_atomic(kaddr, KM_USER0);
755
756 kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
757 header = nilfs_cpfile_block_get_header(cpfile, header_bh, kaddr);
758 le64_add_cpu(&header->ch_nsnapshots, -1);
759 kunmap_atomic(kaddr, KM_USER0);
760
761 nilfs_mdt_mark_buffer_dirty(next_bh);
762 nilfs_mdt_mark_buffer_dirty(prev_bh);
763 nilfs_mdt_mark_buffer_dirty(cp_bh);
764 nilfs_mdt_mark_buffer_dirty(header_bh);
765 nilfs_mdt_mark_dirty(cpfile);
766
767 brelse(prev_bh);
768
769 out_next:
770 brelse(next_bh);
771
772 out_header:
773 brelse(header_bh);
774
775 out_cp:
776 brelse(cp_bh);
777
778 out_sem:
779 up_write(&NILFS_MDT(cpfile)->mi_sem);
780 return ret;
781 }
782
783 /**
784 * nilfs_cpfile_is_snapshot -
785 * @cpfile: inode of checkpoint file
786 * @cno: checkpoint number
787 *
788 * Description:
789 *
790 * Return Value: On success, 1 is returned if the checkpoint specified by
791 * @cno is a snapshot, or 0 if not. On error, one of the following negative
792 * error codes is returned.
793 *
794 * %-EIO - I/O error.
795 *
796 * %-ENOMEM - Insufficient amount of memory available.
797 *
798 * %-ENOENT - No such checkpoint.
799 */
800 int nilfs_cpfile_is_snapshot(struct inode *cpfile, __u64 cno)
801 {
802 struct buffer_head *bh;
803 struct nilfs_checkpoint *cp;
804 void *kaddr;
805 int ret;
806
807 down_read(&NILFS_MDT(cpfile)->mi_sem);
808
809 ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &bh);
810 if (ret < 0)
811 goto out;
812 kaddr = kmap_atomic(bh->b_page, KM_USER0);
813 cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, bh, kaddr);
814 ret = nilfs_checkpoint_snapshot(cp);
815 kunmap_atomic(kaddr, KM_USER0);
816 brelse(bh);
817
818 out:
819 up_read(&NILFS_MDT(cpfile)->mi_sem);
820 return ret;
821 }
822
823 /**
824 * nilfs_cpfile_change_cpmode - change checkpoint mode
825 * @cpfile: inode of checkpoint file
826 * @cno: checkpoint number
827 * @status: mode of checkpoint
828 *
829 * Description: nilfs_change_cpmode() changes the mode of the checkpoint
830 * specified by @cno. The mode @mode is NILFS_CHECKPOINT or NILFS_SNAPSHOT.
831 *
832 * Return Value: On success, 0 is returned. On error, one of the following
833 * negative error codes is returned.
834 *
835 * %-EIO - I/O error.
836 *
837 * %-ENOMEM - Insufficient amount of memory available.
838 *
839 * %-ENOENT - No such checkpoint.
840 */
841 int nilfs_cpfile_change_cpmode(struct inode *cpfile, __u64 cno, int mode)
842 {
843 struct the_nilfs *nilfs;
844 int ret;
845
846 nilfs = NILFS_MDT(cpfile)->mi_nilfs;
847
848 switch (mode) {
849 case NILFS_CHECKPOINT:
850 /*
851 * Check for protecting existing snapshot mounts:
852 * bd_mount_sem is used to make this operation atomic and
853 * exclusive with a new mount job. Though it doesn't cover
854 * umount, it's enough for the purpose.
855 */
856 down(&nilfs->ns_bdev->bd_mount_sem);
857 if (nilfs_checkpoint_is_mounted(nilfs, cno, 1)) {
858 /* Current implementation does not have to protect
859 plain read-only mounts since they are exclusive
860 with a read/write mount and are protected from the
861 cleaner. */
862 ret = -EBUSY;
863 } else
864 ret = nilfs_cpfile_clear_snapshot(cpfile, cno);
865 up(&nilfs->ns_bdev->bd_mount_sem);
866 return ret;
867 case NILFS_SNAPSHOT:
868 return nilfs_cpfile_set_snapshot(cpfile, cno);
869 default:
870 return -EINVAL;
871 }
872 }
873
874 /**
875 * nilfs_cpfile_get_stat - get checkpoint statistics
876 * @cpfile: inode of checkpoint file
877 * @stat: pointer to a structure of checkpoint statistics
878 *
879 * Description: nilfs_cpfile_get_stat() returns information about checkpoints.
880 *
881 * Return Value: On success, 0 is returned, and checkpoints information is
882 * stored in the place pointed by @stat. On error, one of the following
883 * negative error codes is returned.
884 *
885 * %-EIO - I/O error.
886 *
887 * %-ENOMEM - Insufficient amount of memory available.
888 */
889 int nilfs_cpfile_get_stat(struct inode *cpfile, struct nilfs_cpstat *cpstat)
890 {
891 struct buffer_head *bh;
892 struct nilfs_cpfile_header *header;
893 void *kaddr;
894 int ret;
895
896 down_read(&NILFS_MDT(cpfile)->mi_sem);
897
898 ret = nilfs_cpfile_get_header_block(cpfile, &bh);
899 if (ret < 0)
900 goto out_sem;
901 kaddr = kmap_atomic(bh->b_page, KM_USER0);
902 header = nilfs_cpfile_block_get_header(cpfile, bh, kaddr);
903 cpstat->cs_cno = nilfs_mdt_cno(cpfile);
904 cpstat->cs_ncps = le64_to_cpu(header->ch_ncheckpoints);
905 cpstat->cs_nsss = le64_to_cpu(header->ch_nsnapshots);
906 kunmap_atomic(kaddr, KM_USER0);
907 brelse(bh);
908
909 out_sem:
910 up_read(&NILFS_MDT(cpfile)->mi_sem);
911 return ret;
912 }
This page took 0.063116 seconds and 6 git commands to generate.