82462acd06eecb22ccd94353f0d8beab12a2a6b8
2 * cpfile.c - NILFS checkpoint file.
4 * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
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.
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.
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
20 * Written by Koji Sato <koji@osrg.net>.
23 #include <linux/kernel.h>
25 #include <linux/string.h>
26 #include <linux/buffer_head.h>
27 #include <linux/errno.h>
28 #include <linux/nilfs2_fs.h>
33 static inline unsigned long
34 nilfs_cpfile_checkpoints_per_block(const struct inode
*cpfile
)
36 return NILFS_MDT(cpfile
)->mi_entries_per_block
;
39 /* block number from the beginning of the file */
41 nilfs_cpfile_get_blkoff(const struct inode
*cpfile
, __u64 cno
)
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
;
53 nilfs_cpfile_get_offset(const struct inode
*cpfile
, __u64 cno
)
55 __u64 tcno
= cno
+ NILFS_MDT(cpfile
)->mi_first_entry_offset
- 1;
56 return do_div(tcno
, nilfs_cpfile_checkpoints_per_block(cpfile
));
60 nilfs_cpfile_checkpoints_in_block(const struct inode
*cpfile
,
65 nilfs_cpfile_checkpoints_per_block(cpfile
) -
66 nilfs_cpfile_get_offset(cpfile
, curr
),
70 static inline int nilfs_cpfile_is_in_first(const struct inode
*cpfile
,
73 return nilfs_cpfile_get_blkoff(cpfile
, cno
) == 0;
77 nilfs_cpfile_block_add_valid_checkpoints(const struct inode
*cpfile
,
78 struct buffer_head
*bh
,
82 struct nilfs_checkpoint
*cp
= kaddr
+ bh_offset(bh
);
85 count
= le32_to_cpu(cp
->cp_checkpoints_count
) + n
;
86 cp
->cp_checkpoints_count
= cpu_to_le32(count
);
91 nilfs_cpfile_block_sub_valid_checkpoints(const struct inode
*cpfile
,
92 struct buffer_head
*bh
,
96 struct nilfs_checkpoint
*cp
= kaddr
+ bh_offset(bh
);
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
);
105 static inline struct nilfs_cpfile_header
*
106 nilfs_cpfile_block_get_header(const struct inode
*cpfile
,
107 struct buffer_head
*bh
,
110 return kaddr
+ bh_offset(bh
);
113 static struct nilfs_checkpoint
*
114 nilfs_cpfile_block_get_checkpoint(const struct inode
*cpfile
, __u64 cno
,
115 struct buffer_head
*bh
,
118 return kaddr
+ bh_offset(bh
) + nilfs_cpfile_get_offset(cpfile
, cno
) *
119 NILFS_MDT(cpfile
)->mi_entry_size
;
122 static void nilfs_cpfile_block_init(struct inode
*cpfile
,
123 struct buffer_head
*bh
,
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
);
131 nilfs_checkpoint_set_invalid(cp
);
132 cp
= (void *)cp
+ cpsz
;
136 static inline int nilfs_cpfile_get_header_block(struct inode
*cpfile
,
137 struct buffer_head
**bhp
)
139 return nilfs_mdt_get_block(cpfile
, 0, 0, NULL
, bhp
);
142 static inline int nilfs_cpfile_get_checkpoint_block(struct inode
*cpfile
,
145 struct buffer_head
**bhp
)
147 return nilfs_mdt_get_block(cpfile
,
148 nilfs_cpfile_get_blkoff(cpfile
, cno
),
149 create
, nilfs_cpfile_block_init
, bhp
);
152 static inline int nilfs_cpfile_delete_checkpoint_block(struct inode
*cpfile
,
155 return nilfs_mdt_delete_block(cpfile
,
156 nilfs_cpfile_get_blkoff(cpfile
, cno
));
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
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.
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.
178 * %-ENOMEM - Insufficient amount of memory available.
180 * %-ENOENT - No such checkpoint.
182 int nilfs_cpfile_get_checkpoint(struct inode
*cpfile
,
185 struct nilfs_checkpoint
**cpp
,
186 struct buffer_head
**bhp
)
188 struct buffer_head
*header_bh
, *cp_bh
;
189 struct nilfs_cpfile_header
*header
;
190 struct nilfs_checkpoint
*cp
;
194 BUG_ON(cno
< 1 || cno
> nilfs_mdt_cno(cpfile
) ||
195 (cno
< nilfs_mdt_cno(cpfile
) && create
));
197 down_write(&NILFS_MDT(cpfile
)->mi_sem
);
199 ret
= nilfs_cpfile_get_header_block(cpfile
, &header_bh
);
202 ret
= nilfs_cpfile_get_checkpoint_block(cpfile
, cno
, create
, &cp_bh
);
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
)) {
209 kunmap(cp_bh
->b_page
);
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
,
219 nilfs_mdt_mark_buffer_dirty(cp_bh
);
221 kaddr
= kmap_atomic(header_bh
->b_page
, KM_USER0
);
222 header
= nilfs_cpfile_block_get_header(cpfile
, header_bh
,
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
);
238 up_write(&NILFS_MDT(cpfile
)->mi_sem
);
243 * nilfs_cpfile_put_checkpoint - put a checkpoint
244 * @cpfile: inode of checkpoint file
245 * @cno: checkpoint number
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.
252 void nilfs_cpfile_put_checkpoint(struct inode
*cpfile
, __u64 cno
,
253 struct buffer_head
*bh
)
260 * nilfs_cpfile_delete_checkpoints - delete checkpoints
261 * @cpfile: inode of checkpoint file
262 * @start: start checkpoint number
263 * @end: end checkpoint numer
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.
269 * Return Value: On success, 0 is returned. On error, one of the following
270 * negative error codes is returned.
274 * %-ENOMEM - Insufficient amount of memory available.
276 * %-EINVAL - invalid checkpoints.
278 int nilfs_cpfile_delete_checkpoints(struct inode
*cpfile
,
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
;
288 unsigned long tnicps
;
289 int ret
, ncps
, nicps
, count
, i
;
291 if ((start
== 0) || (start
> end
)) {
292 printk(KERN_CRIT
"%s: start = %llu, end = %llu\n",
294 (unsigned long long)start
,
295 (unsigned long long)end
);
299 /* cannot delete the latest checkpoint */
300 if (start
== nilfs_mdt_cno(cpfile
) - 1)
303 down_write(&NILFS_MDT(cpfile
)->mi_sem
);
305 ret
= nilfs_cpfile_get_header_block(cpfile
, &header_bh
);
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
);
321 kaddr
= kmap_atomic(cp_bh
->b_page
, KM_USER0
);
322 cp
= nilfs_cpfile_block_get_checkpoint(
323 cpfile
, cno
, cp_bh
, kaddr
);
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
);
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) {
340 kunmap_atomic(kaddr
, KM_USER0
);
342 ret
= nilfs_cpfile_delete_checkpoint_block(
346 printk(KERN_ERR
"%s: cannot delete block\n",
352 kunmap_atomic(kaddr
, KM_USER0
);
357 kaddr
= kmap_atomic(header_bh
->b_page
, KM_USER0
);
358 header
= nilfs_cpfile_block_get_header(cpfile
, header_bh
,
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
);
368 up_write(&NILFS_MDT(cpfile
)->mi_sem
);
372 static void nilfs_cpfile_checkpoint_to_cpinfo(struct inode
*cpfile
,
373 struct nilfs_checkpoint
*cp
,
374 struct nilfs_cpinfo
*ci
)
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
);
385 static ssize_t
nilfs_cpfile_do_get_cpinfo(struct inode
*cpfile
, __u64 cno
,
386 struct nilfs_cpinfo
*ci
, size_t nci
)
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
);
396 down_read(&NILFS_MDT(cpfile
)->mi_sem
);
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
);
404 continue; /* skip hole */
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
++]);
414 kunmap_atomic(kaddr
, KM_USER0
);
421 up_read(&NILFS_MDT(cpfile
)->mi_sem
);
425 static ssize_t
nilfs_cpfile_do_get_ssinfo(struct inode
*cpfile
, __u64 cno
,
426 struct nilfs_cpinfo
*ci
, size_t nci
)
428 struct buffer_head
*bh
;
429 struct nilfs_cpfile_header
*header
;
430 struct nilfs_checkpoint
*cp
;
432 unsigned long curr_blkoff
, next_blkoff
;
436 down_read(&NILFS_MDT(cpfile
)->mi_sem
);
439 ret
= nilfs_cpfile_get_header_block(cpfile
, &bh
);
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
);
453 curr_blkoff
= nilfs_cpfile_get_blkoff(cpfile
, curr
);
454 ret
= nilfs_cpfile_get_checkpoint_block(cpfile
, curr
, 0, &bh
);
457 kaddr
= kmap_atomic(bh
->b_page
, KM_USER0
);
458 for (n
= 0; n
< nci
; n
++) {
459 cp
= nilfs_cpfile_block_get_checkpoint(
460 cpfile
, curr
, bh
, kaddr
);
461 nilfs_cpfile_checkpoint_to_cpinfo(cpfile
, cp
, &ci
[n
]);
462 next
= le64_to_cpu(cp
->cp_snapshot_list
.ssl_next
);
468 next_blkoff
= nilfs_cpfile_get_blkoff(cpfile
, next
);
469 if (curr_blkoff
!= next_blkoff
) {
470 kunmap_atomic(kaddr
, KM_USER0
);
472 ret
= nilfs_cpfile_get_checkpoint_block(cpfile
, next
,
476 kaddr
= kmap_atomic(bh
->b_page
, KM_USER0
);
479 curr_blkoff
= next_blkoff
;
481 kunmap_atomic(kaddr
, KM_USER0
);
486 up_read(&NILFS_MDT(cpfile
)->mi_sem
);
491 * nilfs_cpfile_get_cpinfo -
497 ssize_t
nilfs_cpfile_get_cpinfo(struct inode
*cpfile
,
499 struct nilfs_cpinfo
*ci
, size_t nci
)
502 case NILFS_CHECKPOINT
:
503 return nilfs_cpfile_do_get_cpinfo(cpfile
, cno
, ci
, nci
);
505 return nilfs_cpfile_do_get_ssinfo(cpfile
, cno
, ci
, nci
);
512 * nilfs_cpfile_delete_checkpoint -
516 int nilfs_cpfile_delete_checkpoint(struct inode
*cpfile
, __u64 cno
)
518 struct nilfs_cpinfo ci
;
522 /* checkpoint number 0 is invalid */
525 nci
= nilfs_cpfile_do_get_cpinfo(cpfile
, cno
, &ci
, 1);
528 else if (nci
== 0 || ci
.ci_cno
!= cno
)
531 /* cannot delete the latest checkpoint nor snapshots */
532 ret
= nilfs_cpinfo_snapshot(&ci
);
535 else if (ret
> 0 || cno
== nilfs_mdt_cno(cpfile
) - 1)
538 return nilfs_cpfile_delete_checkpoints(cpfile
, cno
, cno
+ 1);
541 static struct nilfs_snapshot_list
*
542 nilfs_cpfile_block_get_snapshot_list(const struct inode
*cpfile
,
544 struct buffer_head
*bh
,
547 struct nilfs_cpfile_header
*header
;
548 struct nilfs_checkpoint
*cp
;
549 struct nilfs_snapshot_list
*list
;
552 cp
= nilfs_cpfile_block_get_checkpoint(cpfile
, cno
, bh
, kaddr
);
553 list
= &cp
->cp_snapshot_list
;
555 header
= nilfs_cpfile_block_get_header(cpfile
, bh
, kaddr
);
556 list
= &header
->ch_snapshot_list
;
561 static int nilfs_cpfile_set_snapshot(struct inode
*cpfile
, __u64 cno
)
563 struct buffer_head
*header_bh
, *curr_bh
, *prev_bh
, *cp_bh
;
564 struct nilfs_cpfile_header
*header
;
565 struct nilfs_checkpoint
*cp
;
566 struct nilfs_snapshot_list
*list
;
568 unsigned long curr_blkoff
, prev_blkoff
;
572 down_write(&NILFS_MDT(cpfile
)->mi_sem
);
574 ret
= nilfs_cpfile_get_checkpoint_block(cpfile
, cno
, 0, &cp_bh
);
577 kaddr
= kmap_atomic(cp_bh
->b_page
, KM_USER0
);
578 cp
= nilfs_cpfile_block_get_checkpoint(cpfile
, cno
, cp_bh
, kaddr
);
579 if (nilfs_checkpoint_invalid(cp
)) {
581 kunmap_atomic(kaddr
, KM_USER0
);
584 if (nilfs_checkpoint_snapshot(cp
)) {
586 kunmap_atomic(kaddr
, KM_USER0
);
589 kunmap_atomic(kaddr
, KM_USER0
);
591 ret
= nilfs_cpfile_get_header_block(cpfile
, &header_bh
);
594 kaddr
= kmap_atomic(header_bh
->b_page
, KM_USER0
);
595 header
= nilfs_cpfile_block_get_header(cpfile
, header_bh
, kaddr
);
596 list
= &header
->ch_snapshot_list
;
601 prev
= le64_to_cpu(list
->ssl_prev
);
603 prev_blkoff
= nilfs_cpfile_get_blkoff(cpfile
, prev
);
605 if (curr_blkoff
!= prev_blkoff
) {
606 kunmap_atomic(kaddr
, KM_USER0
);
608 ret
= nilfs_cpfile_get_checkpoint_block(cpfile
, curr
,
612 kaddr
= kmap_atomic(curr_bh
->b_page
, KM_USER0
);
614 curr_blkoff
= prev_blkoff
;
615 cp
= nilfs_cpfile_block_get_checkpoint(
616 cpfile
, curr
, curr_bh
, kaddr
);
617 list
= &cp
->cp_snapshot_list
;
618 prev
= le64_to_cpu(list
->ssl_prev
);
620 kunmap_atomic(kaddr
, KM_USER0
);
623 ret
= nilfs_cpfile_get_checkpoint_block(cpfile
, prev
, 0,
632 kaddr
= kmap_atomic(curr_bh
->b_page
, KM_USER0
);
633 list
= nilfs_cpfile_block_get_snapshot_list(
634 cpfile
, curr
, curr_bh
, kaddr
);
635 list
->ssl_prev
= cpu_to_le64(cno
);
636 kunmap_atomic(kaddr
, KM_USER0
);
638 kaddr
= kmap_atomic(cp_bh
->b_page
, KM_USER0
);
639 cp
= nilfs_cpfile_block_get_checkpoint(cpfile
, cno
, cp_bh
, kaddr
);
640 cp
->cp_snapshot_list
.ssl_next
= cpu_to_le64(curr
);
641 cp
->cp_snapshot_list
.ssl_prev
= cpu_to_le64(prev
);
642 nilfs_checkpoint_set_snapshot(cp
);
643 kunmap_atomic(kaddr
, KM_USER0
);
645 kaddr
= kmap_atomic(prev_bh
->b_page
, KM_USER0
);
646 list
= nilfs_cpfile_block_get_snapshot_list(
647 cpfile
, prev
, prev_bh
, kaddr
);
648 list
->ssl_next
= cpu_to_le64(cno
);
649 kunmap_atomic(kaddr
, KM_USER0
);
651 kaddr
= kmap_atomic(header_bh
->b_page
, KM_USER0
);
652 header
= nilfs_cpfile_block_get_header(cpfile
, header_bh
, kaddr
);
653 le64_add_cpu(&header
->ch_nsnapshots
, 1);
654 kunmap_atomic(kaddr
, KM_USER0
);
656 nilfs_mdt_mark_buffer_dirty(prev_bh
);
657 nilfs_mdt_mark_buffer_dirty(curr_bh
);
658 nilfs_mdt_mark_buffer_dirty(cp_bh
);
659 nilfs_mdt_mark_buffer_dirty(header_bh
);
660 nilfs_mdt_mark_dirty(cpfile
);
674 up_write(&NILFS_MDT(cpfile
)->mi_sem
);
678 static int nilfs_cpfile_clear_snapshot(struct inode
*cpfile
, __u64 cno
)
680 struct buffer_head
*header_bh
, *next_bh
, *prev_bh
, *cp_bh
;
681 struct nilfs_cpfile_header
*header
;
682 struct nilfs_checkpoint
*cp
;
683 struct nilfs_snapshot_list
*list
;
688 down_write(&NILFS_MDT(cpfile
)->mi_sem
);
690 ret
= nilfs_cpfile_get_checkpoint_block(cpfile
, cno
, 0, &cp_bh
);
693 kaddr
= kmap_atomic(cp_bh
->b_page
, KM_USER0
);
694 cp
= nilfs_cpfile_block_get_checkpoint(cpfile
, cno
, cp_bh
, kaddr
);
695 if (nilfs_checkpoint_invalid(cp
)) {
697 kunmap_atomic(kaddr
, KM_USER0
);
700 if (!nilfs_checkpoint_snapshot(cp
)) {
702 kunmap_atomic(kaddr
, KM_USER0
);
706 list
= &cp
->cp_snapshot_list
;
707 next
= le64_to_cpu(list
->ssl_next
);
708 prev
= le64_to_cpu(list
->ssl_prev
);
709 kunmap_atomic(kaddr
, KM_USER0
);
711 ret
= nilfs_cpfile_get_header_block(cpfile
, &header_bh
);
715 ret
= nilfs_cpfile_get_checkpoint_block(cpfile
, next
, 0,
724 ret
= nilfs_cpfile_get_checkpoint_block(cpfile
, prev
, 0,
733 kaddr
= kmap_atomic(next_bh
->b_page
, KM_USER0
);
734 list
= nilfs_cpfile_block_get_snapshot_list(
735 cpfile
, next
, next_bh
, kaddr
);
736 list
->ssl_prev
= cpu_to_le64(prev
);
737 kunmap_atomic(kaddr
, KM_USER0
);
739 kaddr
= kmap_atomic(prev_bh
->b_page
, KM_USER0
);
740 list
= nilfs_cpfile_block_get_snapshot_list(
741 cpfile
, prev
, prev_bh
, kaddr
);
742 list
->ssl_next
= cpu_to_le64(next
);
743 kunmap_atomic(kaddr
, KM_USER0
);
745 kaddr
= kmap_atomic(cp_bh
->b_page
, KM_USER0
);
746 cp
= nilfs_cpfile_block_get_checkpoint(cpfile
, cno
, cp_bh
, kaddr
);
747 cp
->cp_snapshot_list
.ssl_next
= cpu_to_le64(0);
748 cp
->cp_snapshot_list
.ssl_prev
= cpu_to_le64(0);
749 nilfs_checkpoint_clear_snapshot(cp
);
750 kunmap_atomic(kaddr
, KM_USER0
);
752 kaddr
= kmap_atomic(header_bh
->b_page
, KM_USER0
);
753 header
= nilfs_cpfile_block_get_header(cpfile
, header_bh
, kaddr
);
754 le64_add_cpu(&header
->ch_nsnapshots
, -1);
755 kunmap_atomic(kaddr
, KM_USER0
);
757 nilfs_mdt_mark_buffer_dirty(next_bh
);
758 nilfs_mdt_mark_buffer_dirty(prev_bh
);
759 nilfs_mdt_mark_buffer_dirty(cp_bh
);
760 nilfs_mdt_mark_buffer_dirty(header_bh
);
761 nilfs_mdt_mark_dirty(cpfile
);
775 up_write(&NILFS_MDT(cpfile
)->mi_sem
);
780 * nilfs_cpfile_is_snapshot -
781 * @cpfile: inode of checkpoint file
782 * @cno: checkpoint number
786 * Return Value: On success, 1 is returned if the checkpoint specified by
787 * @cno is a snapshot, or 0 if not. On error, one of the following negative
788 * error codes is returned.
792 * %-ENOMEM - Insufficient amount of memory available.
794 * %-ENOENT - No such checkpoint.
796 int nilfs_cpfile_is_snapshot(struct inode
*cpfile
, __u64 cno
)
798 struct buffer_head
*bh
;
799 struct nilfs_checkpoint
*cp
;
803 down_read(&NILFS_MDT(cpfile
)->mi_sem
);
805 ret
= nilfs_cpfile_get_checkpoint_block(cpfile
, cno
, 0, &bh
);
808 kaddr
= kmap_atomic(bh
->b_page
, KM_USER0
);
809 cp
= nilfs_cpfile_block_get_checkpoint(cpfile
, cno
, bh
, kaddr
);
810 ret
= nilfs_checkpoint_snapshot(cp
);
811 kunmap_atomic(kaddr
, KM_USER0
);
815 up_read(&NILFS_MDT(cpfile
)->mi_sem
);
820 * nilfs_cpfile_change_cpmode - change checkpoint mode
821 * @cpfile: inode of checkpoint file
822 * @cno: checkpoint number
823 * @status: mode of checkpoint
825 * Description: nilfs_change_cpmode() changes the mode of the checkpoint
826 * specified by @cno. The mode @mode is NILFS_CHECKPOINT or NILFS_SNAPSHOT.
828 * Return Value: On success, 0 is returned. On error, one of the following
829 * negative error codes is returned.
833 * %-ENOMEM - Insufficient amount of memory available.
835 * %-ENOENT - No such checkpoint.
837 int nilfs_cpfile_change_cpmode(struct inode
*cpfile
, __u64 cno
, int mode
)
839 struct the_nilfs
*nilfs
;
842 nilfs
= NILFS_MDT(cpfile
)->mi_nilfs
;
845 case NILFS_CHECKPOINT
:
847 * Check for protecting existing snapshot mounts:
848 * bd_mount_sem is used to make this operation atomic and
849 * exclusive with a new mount job. Though it doesn't cover
850 * umount, it's enough for the purpose.
852 down(&nilfs
->ns_bdev
->bd_mount_sem
);
853 if (nilfs_checkpoint_is_mounted(nilfs
, cno
, 1)) {
854 /* Current implementation does not have to protect
855 plain read-only mounts since they are exclusive
856 with a read/write mount and are protected from the
860 ret
= nilfs_cpfile_clear_snapshot(cpfile
, cno
);
861 up(&nilfs
->ns_bdev
->bd_mount_sem
);
864 return nilfs_cpfile_set_snapshot(cpfile
, cno
);
871 * nilfs_cpfile_get_stat - get checkpoint statistics
872 * @cpfile: inode of checkpoint file
873 * @stat: pointer to a structure of checkpoint statistics
875 * Description: nilfs_cpfile_get_stat() returns information about checkpoints.
877 * Return Value: On success, 0 is returned, and checkpoints information is
878 * stored in the place pointed by @stat. On error, one of the following
879 * negative error codes is returned.
883 * %-ENOMEM - Insufficient amount of memory available.
885 int nilfs_cpfile_get_stat(struct inode
*cpfile
, struct nilfs_cpstat
*cpstat
)
887 struct buffer_head
*bh
;
888 struct nilfs_cpfile_header
*header
;
892 down_read(&NILFS_MDT(cpfile
)->mi_sem
);
894 ret
= nilfs_cpfile_get_header_block(cpfile
, &bh
);
897 kaddr
= kmap_atomic(bh
->b_page
, KM_USER0
);
898 header
= nilfs_cpfile_block_get_header(cpfile
, bh
, kaddr
);
899 cpstat
->cs_cno
= nilfs_mdt_cno(cpfile
);
900 cpstat
->cs_ncps
= le64_to_cpu(header
->ch_ncheckpoints
);
901 cpstat
->cs_nsss
= le64_to_cpu(header
->ch_nsnapshots
);
902 kunmap_atomic(kaddr
, KM_USER0
);
906 up_read(&NILFS_MDT(cpfile
)->mi_sem
);
This page took 0.051725 seconds and 4 git commands to generate.