Commit a6cb5b1e authored by Ryusuke Konishi's avatar Ryusuke Konishi Committed by Andrew Morton
Browse files

nilfs2: convert checkpoint file to be folio-based 

Regarding the cpfile, a metadata file that manages checkpoints, convert
the page-based implementation to a folio-based implementation.

This change involves some helper functions to calculate byte offsets on
folios and removing a few helper functions that are no longer needed.

Link: https://lkml.kernel.org/r/20241024092602.13395-9-konishi.ryusuke@gmail.com


Signed-off-by: default avatarRyusuke Konishi <konishi.ryusuke@gmail.com>
Cc: Matthew Wilcox (Oracle) <willy@infradead.org>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
parent cdee1796

fs/nilfs2/cpfile.c

+204 −175
Original line number Diff line number Diff line
@@ -68,49 +68,36 @@ static inline int nilfs_cpfile_is_in_first(const struct inode *cpfile, 
static unsigned int

nilfs_cpfile_block_add_valid_checkpoints(const struct inode *cpfile,

					 struct buffer_head *bh,

					 void *kaddr,

					 unsigned int n)

{

	struct nilfs_checkpoint *cp = kaddr + bh_offset(bh);

	struct nilfs_checkpoint *cp;

	unsigned int count;



	cp = kmap_local_folio(bh->b_folio,

			      offset_in_folio(bh->b_folio, bh->b_data));

	count = le32_to_cpu(cp->cp_checkpoints_count) + n;

	cp->cp_checkpoints_count = cpu_to_le32(count);

	kunmap_local(cp);

	return count;

}



static unsigned int

nilfs_cpfile_block_sub_valid_checkpoints(const struct inode *cpfile,

					 struct buffer_head *bh,

					 void *kaddr,

					 unsigned int n)

{

	struct nilfs_checkpoint *cp = kaddr + bh_offset(bh);

	struct nilfs_checkpoint *cp;

	unsigned int count;



	cp = kmap_local_folio(bh->b_folio,

			      offset_in_folio(bh->b_folio, bh->b_data));

	WARN_ON(le32_to_cpu(cp->cp_checkpoints_count) < n);

	count = le32_to_cpu(cp->cp_checkpoints_count) - n;

	cp->cp_checkpoints_count = cpu_to_le32(count);

	kunmap_local(cp);

	return count;

}



static inline struct nilfs_cpfile_header *

nilfs_cpfile_block_get_header(const struct inode *cpfile,

			      struct buffer_head *bh,

			      void *kaddr)

{

	return kaddr + bh_offset(bh);

}



static struct nilfs_checkpoint *

nilfs_cpfile_block_get_checkpoint(const struct inode *cpfile, __u64 cno,

				  struct buffer_head *bh,

				  void *kaddr)

{

	return kaddr + bh_offset(bh) + nilfs_cpfile_get_offset(cpfile, cno) *

		NILFS_MDT(cpfile)->mi_entry_size;

}



static void nilfs_cpfile_block_init(struct inode *cpfile,

				    struct buffer_head *bh,

				    void *from)
@@ -125,6 +112,54 @@ static void nilfs_cpfile_block_init(struct inode *cpfile, 
	}

}



/**

 * nilfs_cpfile_checkpoint_offset - calculate the byte offset of a checkpoint

 *                                  entry in the folio containing it

 * @cpfile: checkpoint file inode

 * @cno:    checkpoint number

 * @bh:     buffer head of block containing checkpoint indexed by @cno

 *

 * Return: Byte offset in the folio of the checkpoint specified by @cno.

 */

static size_t nilfs_cpfile_checkpoint_offset(const struct inode *cpfile,

					     __u64 cno,

					     struct buffer_head *bh)

{

	return offset_in_folio(bh->b_folio, bh->b_data) +

		nilfs_cpfile_get_offset(cpfile, cno) *

		NILFS_MDT(cpfile)->mi_entry_size;

}



/**

 * nilfs_cpfile_cp_snapshot_list_offset - calculate the byte offset of a

 *                                        checkpoint snapshot list in the folio

 *                                        containing it

 * @cpfile: checkpoint file inode

 * @cno:    checkpoint number

 * @bh:     buffer head of block containing checkpoint indexed by @cno

 *

 * Return: Byte offset in the folio of the checkpoint snapshot list specified

 *         by @cno.

 */

static size_t nilfs_cpfile_cp_snapshot_list_offset(const struct inode *cpfile,

						   __u64 cno,

						   struct buffer_head *bh)

{

	return nilfs_cpfile_checkpoint_offset(cpfile, cno, bh) +

		offsetof(struct nilfs_checkpoint, cp_snapshot_list);

}



/**

 * nilfs_cpfile_ch_snapshot_list_offset - calculate the byte offset of the

 *                                        snapshot list in the header

 *

 * Return: Byte offset in the folio of the checkpoint snapshot list

 */

static size_t nilfs_cpfile_ch_snapshot_list_offset(void)

{

	return offsetof(struct nilfs_cpfile_header, ch_snapshot_list);

}



static int nilfs_cpfile_get_header_block(struct inode *cpfile,

					 struct buffer_head **bhp)

{
@@ -214,7 +249,7 @@ int nilfs_cpfile_read_checkpoint(struct inode *cpfile, __u64 cno, 
{

	struct buffer_head *cp_bh;

	struct nilfs_checkpoint *cp;

	void *kaddr;

	size_t offset;

	int ret;



	if (cno < 1 || cno > nilfs_mdt_cno(cpfile))
@@ -228,8 +263,8 @@ int nilfs_cpfile_read_checkpoint(struct inode *cpfile, __u64 cno, 
		goto out_sem;

	}



	kaddr = kmap_local_page(cp_bh->b_page);

	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);

	offset = nilfs_cpfile_checkpoint_offset(cpfile, cno, cp_bh);

	cp = kmap_local_folio(cp_bh->b_folio, offset);

	if (nilfs_checkpoint_invalid(cp)) {

		ret = -EINVAL;

		goto put_cp;
@@ -254,7 +289,7 @@ int nilfs_cpfile_read_checkpoint(struct inode *cpfile, __u64 cno, 
	root->ifile = ifile;



put_cp:

	kunmap_local(kaddr);

	kunmap_local(cp);

	brelse(cp_bh);

out_sem:

	up_read(&NILFS_MDT(cpfile)->mi_sem);
@@ -282,7 +317,7 @@ int nilfs_cpfile_create_checkpoint(struct inode *cpfile, __u64 cno) 
	struct buffer_head *header_bh, *cp_bh;

	struct nilfs_cpfile_header *header;

	struct nilfs_checkpoint *cp;

	void *kaddr;

	size_t offset;

	int ret;



	if (WARN_ON_ONCE(cno < 1))
@@ -297,24 +332,22 @@ int nilfs_cpfile_create_checkpoint(struct inode *cpfile, __u64 cno) 
	if (unlikely(ret < 0))

		goto out_header;



	kaddr = kmap_local_page(cp_bh->b_page);

	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);

	offset = nilfs_cpfile_checkpoint_offset(cpfile, cno, cp_bh);

	cp = kmap_local_folio(cp_bh->b_folio, offset);

	if (nilfs_checkpoint_invalid(cp)) {

		/* a newly-created checkpoint */

		nilfs_checkpoint_clear_invalid(cp);

		kunmap_local(cp);

		if (!nilfs_cpfile_is_in_first(cpfile, cno))

			nilfs_cpfile_block_add_valid_checkpoints(cpfile, cp_bh,

								 kaddr, 1);

		kunmap_local(kaddr);

								 1);



		kaddr = kmap_local_page(header_bh->b_page);

		header = nilfs_cpfile_block_get_header(cpfile, header_bh,

						       kaddr);

		header = kmap_local_folio(header_bh->b_folio, 0);

		le64_add_cpu(&header->ch_ncheckpoints, 1);

		kunmap_local(kaddr);

		kunmap_local(header);

		mark_buffer_dirty(header_bh);

	} else {

		kunmap_local(kaddr);

		kunmap_local(cp);

	}



	/* Force the buffer and the inode to become dirty */
@@ -353,7 +386,7 @@ int nilfs_cpfile_finalize_checkpoint(struct inode *cpfile, __u64 cno, 
{

	struct buffer_head *cp_bh;

	struct nilfs_checkpoint *cp;

	void *kaddr;

	size_t offset;

	int ret;



	if (WARN_ON_ONCE(cno < 1))
@@ -367,10 +400,10 @@ int nilfs_cpfile_finalize_checkpoint(struct inode *cpfile, __u64 cno, 
		goto out_sem;

	}



	kaddr = kmap_local_page(cp_bh->b_page);

	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);

	offset = nilfs_cpfile_checkpoint_offset(cpfile, cno, cp_bh);

	cp = kmap_local_folio(cp_bh->b_folio, offset);

	if (unlikely(nilfs_checkpoint_invalid(cp))) {

		kunmap_local(kaddr);

		kunmap_local(cp);

		brelse(cp_bh);

		goto error;

	}
@@ -391,7 +424,7 @@ int nilfs_cpfile_finalize_checkpoint(struct inode *cpfile, __u64 cno, 
	nilfs_write_inode_common(root->ifile, &cp->cp_ifile_inode);

	nilfs_bmap_write(NILFS_I(root->ifile)->i_bmap, &cp->cp_ifile_inode);



	kunmap_local(kaddr);

	kunmap_local(cp);

	brelse(cp_bh);

out_sem:

	up_write(&NILFS_MDT(cpfile)->mi_sem);
@@ -432,6 +465,7 @@ int nilfs_cpfile_delete_checkpoints(struct inode *cpfile, 
	struct nilfs_checkpoint *cp;

	size_t cpsz = NILFS_MDT(cpfile)->mi_entry_size;

	__u64 cno;

	size_t offset;

	void *kaddr;

	unsigned long tnicps;

	int ret, ncps, nicps, nss, count, i;
@@ -462,9 +496,8 @@ int nilfs_cpfile_delete_checkpoints(struct inode *cpfile, 
			continue;

		}



		kaddr = kmap_local_page(cp_bh->b_page);

		cp = nilfs_cpfile_block_get_checkpoint(

			cpfile, cno, cp_bh, kaddr);

		offset = nilfs_cpfile_checkpoint_offset(cpfile, cno, cp_bh);

		cp = kaddr = kmap_local_folio(cp_bh->b_folio, offset);

		nicps = 0;

		for (i = 0; i < ncps; i++, cp = (void *)cp + cpsz) {

			if (nilfs_checkpoint_snapshot(cp)) {
@@ -474,43 +507,42 @@ int nilfs_cpfile_delete_checkpoints(struct inode *cpfile, 
				nicps++;

			}

		}

		if (nicps > 0) {

		kunmap_local(kaddr);



		if (nicps <= 0) {

			brelse(cp_bh);

			continue;

		}



		tnicps += nicps;

		mark_buffer_dirty(cp_bh);

		nilfs_mdt_mark_dirty(cpfile);

			if (!nilfs_cpfile_is_in_first(cpfile, cno)) {

				count =

				  nilfs_cpfile_block_sub_valid_checkpoints(

						cpfile, cp_bh, kaddr, nicps);

				if (count == 0) {

					/* make hole */

					kunmap_local(kaddr);

		if (nilfs_cpfile_is_in_first(cpfile, cno)) {

			brelse(cp_bh);

					ret =

					  nilfs_cpfile_delete_checkpoint_block(

								   cpfile, cno);

					if (ret == 0)

			continue;

					nilfs_err(cpfile->i_sb,

						  "error %d deleting checkpoint block",

						  ret);

					break;

				}

			}

		}



		kunmap_local(kaddr);

		count = nilfs_cpfile_block_sub_valid_checkpoints(cpfile, cp_bh,

								 nicps);

		brelse(cp_bh);

		if (count)

			continue;



		/* Delete the block if there are no more valid checkpoints */

		ret = nilfs_cpfile_delete_checkpoint_block(cpfile, cno);

		if (unlikely(ret)) {

			nilfs_err(cpfile->i_sb,

				  "error %d deleting checkpoint block", ret);

			break;

		}

	}



	if (tnicps > 0) {

		kaddr = kmap_local_page(header_bh->b_page);

		header = nilfs_cpfile_block_get_header(cpfile, header_bh,

						       kaddr);

		header = kmap_local_folio(header_bh->b_folio, 0);

		le64_add_cpu(&header->ch_ncheckpoints, -(u64)tnicps);

		mark_buffer_dirty(header_bh);

		nilfs_mdt_mark_dirty(cpfile);

		kunmap_local(kaddr);

		kunmap_local(header);

	}



	brelse(header_bh);
@@ -544,6 +576,7 @@ static ssize_t nilfs_cpfile_do_get_cpinfo(struct inode *cpfile, __u64 *cnop, 
	struct buffer_head *bh;

	size_t cpsz = NILFS_MDT(cpfile)->mi_entry_size;

	__u64 cur_cno = nilfs_mdt_cno(cpfile), cno = *cnop;

	size_t offset;

	void *kaddr;

	int n, ret;

	int ncps, i;
@@ -562,8 +595,8 @@ static ssize_t nilfs_cpfile_do_get_cpinfo(struct inode *cpfile, __u64 *cnop, 
		}

		ncps = nilfs_cpfile_checkpoints_in_block(cpfile, cno, cur_cno);



		kaddr = kmap_local_page(bh->b_page);

		cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, bh, kaddr);

		offset = nilfs_cpfile_checkpoint_offset(cpfile, cno, bh);

		cp = kaddr = kmap_local_folio(bh->b_folio, offset);

		for (i = 0; i < ncps && n < nci; i++, cp = (void *)cp + cpsz) {

			if (!nilfs_checkpoint_invalid(cp)) {

				nilfs_cpfile_checkpoint_to_cpinfo(cpfile, cp,
@@ -597,7 +630,7 @@ static ssize_t nilfs_cpfile_do_get_ssinfo(struct inode *cpfile, __u64 *cnop, 
	struct nilfs_cpinfo *ci = buf;

	__u64 curr = *cnop, next;

	unsigned long curr_blkoff, next_blkoff;

	void *kaddr;

	size_t offset;

	int n = 0, ret;



	down_read(&NILFS_MDT(cpfile)->mi_sem);
@@ -606,10 +639,9 @@ static ssize_t nilfs_cpfile_do_get_ssinfo(struct inode *cpfile, __u64 *cnop, 
		ret = nilfs_cpfile_get_header_block(cpfile, &bh);

		if (ret < 0)

			goto out;

		kaddr = kmap_local_page(bh->b_page);

		header = nilfs_cpfile_block_get_header(cpfile, bh, kaddr);

		header = kmap_local_folio(bh->b_folio, 0);

		curr = le64_to_cpu(header->ch_snapshot_list.ssl_next);

		kunmap_local(kaddr);

		kunmap_local(header);

		brelse(bh);

		if (curr == 0) {

			ret = 0;
@@ -627,9 +659,9 @@ static ssize_t nilfs_cpfile_do_get_ssinfo(struct inode *cpfile, __u64 *cnop, 
			ret = 0; /* No snapshots (started from a hole block) */

		goto out;

	}

	kaddr = kmap_local_page(bh->b_page);

	offset = nilfs_cpfile_checkpoint_offset(cpfile, curr, bh);

	cp = kmap_local_folio(bh->b_folio, offset);

	while (n < nci) {

		cp = nilfs_cpfile_block_get_checkpoint(cpfile, curr, bh, kaddr);

		curr = ~(__u64)0; /* Terminator */

		if (unlikely(nilfs_checkpoint_invalid(cp) ||

			     !nilfs_checkpoint_snapshot(cp)))
@@ -641,9 +673,9 @@ static ssize_t nilfs_cpfile_do_get_ssinfo(struct inode *cpfile, __u64 *cnop, 
		if (next == 0)

			break; /* reach end of the snapshot list */



		kunmap_local(cp);

		next_blkoff = nilfs_cpfile_get_blkoff(cpfile, next);

		if (curr_blkoff != next_blkoff) {

			kunmap_local(kaddr);

			brelse(bh);

			ret = nilfs_cpfile_get_checkpoint_block(cpfile, next,

								0, &bh);
@@ -651,12 +683,13 @@ static ssize_t nilfs_cpfile_do_get_ssinfo(struct inode *cpfile, __u64 *cnop, 
				WARN_ON(ret == -ENOENT);

				goto out;

			}

			kaddr = kmap_local_page(bh->b_page);

		}

		offset = nilfs_cpfile_checkpoint_offset(cpfile, next, bh);

		cp = kmap_local_folio(bh->b_folio, offset);

		curr = next;

		curr_blkoff = next_blkoff;

	}

	kunmap_local(kaddr);

	kunmap_local(cp);

	brelse(bh);

	*cnop = curr;

	ret = n;
@@ -733,26 +766,6 @@ int nilfs_cpfile_delete_checkpoint(struct inode *cpfile, __u64 cno) 
	return nilfs_cpfile_delete_checkpoints(cpfile, cno, cno + 1);

}



static struct nilfs_snapshot_list *

nilfs_cpfile_block_get_snapshot_list(const struct inode *cpfile,

				     __u64 cno,

				     struct buffer_head *bh,

				     void *kaddr)

{

	struct nilfs_cpfile_header *header;

	struct nilfs_checkpoint *cp;

	struct nilfs_snapshot_list *list;



	if (cno != 0) {

		cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, bh, kaddr);

		list = &cp->cp_snapshot_list;

	} else {

		header = nilfs_cpfile_block_get_header(cpfile, bh, kaddr);

		list = &header->ch_snapshot_list;

	}

	return list;

}



static int nilfs_cpfile_set_snapshot(struct inode *cpfile, __u64 cno)

{

	struct buffer_head *header_bh, *curr_bh, *prev_bh, *cp_bh;
@@ -761,94 +774,103 @@ static int nilfs_cpfile_set_snapshot(struct inode *cpfile, __u64 cno) 
	struct nilfs_snapshot_list *list;

	__u64 curr, prev;

	unsigned long curr_blkoff, prev_blkoff;

	void *kaddr;

	size_t offset, curr_list_offset, prev_list_offset;

	int ret;



	if (cno == 0)

		return -ENOENT; /* checkpoint number 0 is invalid */

	down_write(&NILFS_MDT(cpfile)->mi_sem);



	ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);

	if (unlikely(ret < 0))

		goto out_sem;



	ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &cp_bh);

	if (ret < 0)

		goto out_sem;

	kaddr = kmap_local_page(cp_bh->b_page);

	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);

		goto out_header;



	offset = nilfs_cpfile_checkpoint_offset(cpfile, cno, cp_bh);

	cp = kmap_local_folio(cp_bh->b_folio, offset);

	if (nilfs_checkpoint_invalid(cp)) {

		ret = -ENOENT;

		kunmap_local(kaddr);

		kunmap_local(cp);

		goto out_cp;

	}

	if (nilfs_checkpoint_snapshot(cp)) {

		ret = 0;

		kunmap_local(kaddr);

		kunmap_local(cp);

		goto out_cp;

	}

	kunmap_local(kaddr);

	kunmap_local(cp);



	ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);

	if (ret < 0)

		goto out_cp;

	kaddr = kmap_local_page(header_bh->b_page);

	header = nilfs_cpfile_block_get_header(cpfile, header_bh, kaddr);

	/*

	 * Find the last snapshot before the checkpoint being changed to

	 * snapshot mode by going backwards through the snapshot list.

	 * Set "prev" to its checkpoint number, or 0 if not found.

	 */

	header = kmap_local_folio(header_bh->b_folio, 0);

	list = &header->ch_snapshot_list;

	curr_bh = header_bh;

	get_bh(curr_bh);

	curr = 0;

	curr_blkoff = 0;

	curr_list_offset = nilfs_cpfile_ch_snapshot_list_offset();

	prev = le64_to_cpu(list->ssl_prev);

	while (prev > cno) {

		prev_blkoff = nilfs_cpfile_get_blkoff(cpfile, prev);

		curr = prev;

		kunmap_local(list);

		if (curr_blkoff != prev_blkoff) {

			kunmap_local(kaddr);

			brelse(curr_bh);

			ret = nilfs_cpfile_get_checkpoint_block(cpfile, curr,

								0, &curr_bh);

			if (ret < 0)

				goto out_header;

			kaddr = kmap_local_page(curr_bh->b_page);

			if (unlikely(ret < 0))

				goto out_cp;

		}

		curr_list_offset = nilfs_cpfile_cp_snapshot_list_offset(

			cpfile, curr, curr_bh);

		list = kmap_local_folio(curr_bh->b_folio, curr_list_offset);

		curr_blkoff = prev_blkoff;

		cp = nilfs_cpfile_block_get_checkpoint(

			cpfile, curr, curr_bh, kaddr);

		list = &cp->cp_snapshot_list;

		prev = le64_to_cpu(list->ssl_prev);

	}

	kunmap_local(kaddr);

	kunmap_local(list);



	if (prev != 0) {

		ret = nilfs_cpfile_get_checkpoint_block(cpfile, prev, 0,

							&prev_bh);

		if (ret < 0)

			goto out_curr;



		prev_list_offset = nilfs_cpfile_cp_snapshot_list_offset(

			cpfile, prev, prev_bh);

	} else {

		prev_bh = header_bh;

		get_bh(prev_bh);

		prev_list_offset = nilfs_cpfile_ch_snapshot_list_offset();

	}



	kaddr = kmap_local_page(curr_bh->b_page);

	list = nilfs_cpfile_block_get_snapshot_list(

		cpfile, curr, curr_bh, kaddr);

	/* Update the list entry for the next snapshot */

	list = kmap_local_folio(curr_bh->b_folio, curr_list_offset);

	list->ssl_prev = cpu_to_le64(cno);

	kunmap_local(kaddr);

	kunmap_local(list);



	kaddr = kmap_local_page(cp_bh->b_page);

	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);

	/* Update the checkpoint being changed to a snapshot */

	offset = nilfs_cpfile_checkpoint_offset(cpfile, cno, cp_bh);

	cp = kmap_local_folio(cp_bh->b_folio, offset);

	cp->cp_snapshot_list.ssl_next = cpu_to_le64(curr);

	cp->cp_snapshot_list.ssl_prev = cpu_to_le64(prev);

	nilfs_checkpoint_set_snapshot(cp);

	kunmap_local(kaddr);

	kunmap_local(cp);



	kaddr = kmap_local_page(prev_bh->b_page);

	list = nilfs_cpfile_block_get_snapshot_list(

		cpfile, prev, prev_bh, kaddr);

	/* Update the list entry for the previous snapshot */

	list = kmap_local_folio(prev_bh->b_folio, prev_list_offset);

	list->ssl_next = cpu_to_le64(cno);

	kunmap_local(kaddr);

	kunmap_local(list);



	kaddr = kmap_local_page(header_bh->b_page);

	header = nilfs_cpfile_block_get_header(cpfile, header_bh, kaddr);

	/* Update the statistics in the header */

	header = kmap_local_folio(header_bh->b_folio, 0);

	le64_add_cpu(&header->ch_nsnapshots, 1);

	kunmap_local(kaddr);

	kunmap_local(header);



	mark_buffer_dirty(prev_bh);

	mark_buffer_dirty(curr_bh);
@@ -861,12 +883,12 @@ static int nilfs_cpfile_set_snapshot(struct inode *cpfile, __u64 cno) 
 out_curr:

	brelse(curr_bh);



 out_header:

	brelse(header_bh);



 out_cp:

	brelse(cp_bh);



 out_header:

	brelse(header_bh);



 out_sem:

	up_write(&NILFS_MDT(cpfile)->mi_sem);

	return ret;
@@ -879,79 +901,87 @@ static int nilfs_cpfile_clear_snapshot(struct inode *cpfile, __u64 cno) 
	struct nilfs_checkpoint *cp;

	struct nilfs_snapshot_list *list;

	__u64 next, prev;

	void *kaddr;

	size_t offset, next_list_offset, prev_list_offset;

	int ret;



	if (cno == 0)

		return -ENOENT; /* checkpoint number 0 is invalid */

	down_write(&NILFS_MDT(cpfile)->mi_sem);



	ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);

	if (unlikely(ret < 0))

		goto out_sem;



	ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &cp_bh);

	if (ret < 0)

		goto out_sem;

	kaddr = kmap_local_page(cp_bh->b_page);

	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);

		goto out_header;



	offset = nilfs_cpfile_checkpoint_offset(cpfile, cno, cp_bh);

	cp = kmap_local_folio(cp_bh->b_folio, offset);

	if (nilfs_checkpoint_invalid(cp)) {

		ret = -ENOENT;

		kunmap_local(kaddr);

		kunmap_local(cp);

		goto out_cp;

	}

	if (!nilfs_checkpoint_snapshot(cp)) {

		ret = 0;

		kunmap_local(kaddr);

		kunmap_local(cp);

		goto out_cp;

	}



	list = &cp->cp_snapshot_list;

	next = le64_to_cpu(list->ssl_next);

	prev = le64_to_cpu(list->ssl_prev);

	kunmap_local(kaddr);

	kunmap_local(cp);



	ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);

	if (ret < 0)

		goto out_cp;

	if (next != 0) {

		ret = nilfs_cpfile_get_checkpoint_block(cpfile, next, 0,

							&next_bh);

		if (ret < 0)

			goto out_header;

			goto out_cp;



		next_list_offset = nilfs_cpfile_cp_snapshot_list_offset(

			cpfile, next, next_bh);

	} else {

		next_bh = header_bh;

		get_bh(next_bh);

		next_list_offset = nilfs_cpfile_ch_snapshot_list_offset();

	}

	if (prev != 0) {

		ret = nilfs_cpfile_get_checkpoint_block(cpfile, prev, 0,

							&prev_bh);

		if (ret < 0)

			goto out_next;



		prev_list_offset = nilfs_cpfile_cp_snapshot_list_offset(

			cpfile, prev, prev_bh);

	} else {

		prev_bh = header_bh;

		get_bh(prev_bh);

		prev_list_offset = nilfs_cpfile_ch_snapshot_list_offset();

	}



	kaddr = kmap_local_page(next_bh->b_page);

	list = nilfs_cpfile_block_get_snapshot_list(

		cpfile, next, next_bh, kaddr);

	/* Update the list entry for the next snapshot */

	list = kmap_local_folio(next_bh->b_folio, next_list_offset);

	list->ssl_prev = cpu_to_le64(prev);

	kunmap_local(kaddr);

	kunmap_local(list);



	kaddr = kmap_local_page(prev_bh->b_page);

	list = nilfs_cpfile_block_get_snapshot_list(

		cpfile, prev, prev_bh, kaddr);

	/* Update the list entry for the previous snapshot */

	list = kmap_local_folio(prev_bh->b_folio, prev_list_offset);

	list->ssl_next = cpu_to_le64(next);

	kunmap_local(kaddr);

	kunmap_local(list);



	kaddr = kmap_local_page(cp_bh->b_page);

	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);

	/* Update the snapshot being changed back to a plain checkpoint */

	cp = kmap_local_folio(cp_bh->b_folio, offset);

	cp->cp_snapshot_list.ssl_next = cpu_to_le64(0);

	cp->cp_snapshot_list.ssl_prev = cpu_to_le64(0);

	nilfs_checkpoint_clear_snapshot(cp);

	kunmap_local(kaddr);

	kunmap_local(cp);



	kaddr = kmap_local_page(header_bh->b_page);

	header = nilfs_cpfile_block_get_header(cpfile, header_bh, kaddr);

	/* Update the statistics in the header */

	header = kmap_local_folio(header_bh->b_folio, 0);

	le64_add_cpu(&header->ch_nsnapshots, -1);

	kunmap_local(kaddr);

	kunmap_local(header);



	mark_buffer_dirty(next_bh);

	mark_buffer_dirty(prev_bh);
@@ -964,12 +994,12 @@ static int nilfs_cpfile_clear_snapshot(struct inode *cpfile, __u64 cno) 
 out_next:

	brelse(next_bh);



 out_header:

	brelse(header_bh);



 out_cp:

	brelse(cp_bh);



 out_header:

	brelse(header_bh);



 out_sem:

	up_write(&NILFS_MDT(cpfile)->mi_sem);

	return ret;
@@ -990,7 +1020,7 @@ int nilfs_cpfile_is_snapshot(struct inode *cpfile, __u64 cno) 
{

	struct buffer_head *bh;

	struct nilfs_checkpoint *cp;

	void *kaddr;

	size_t offset;

	int ret;



	/*
@@ -1004,13 +1034,14 @@ int nilfs_cpfile_is_snapshot(struct inode *cpfile, __u64 cno) 
	ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &bh);

	if (ret < 0)

		goto out;

	kaddr = kmap_local_page(bh->b_page);

	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, bh, kaddr);



	offset = nilfs_cpfile_checkpoint_offset(cpfile, cno, bh);

	cp = kmap_local_folio(bh->b_folio, offset);

	if (nilfs_checkpoint_invalid(cp))

		ret = -ENOENT;

	else

		ret = nilfs_checkpoint_snapshot(cp);

	kunmap_local(kaddr);

	kunmap_local(cp);

	brelse(bh);



 out:
@@ -1079,7 +1110,6 @@ int nilfs_cpfile_get_stat(struct inode *cpfile, struct nilfs_cpstat *cpstat) 
{

	struct buffer_head *bh;

	struct nilfs_cpfile_header *header;

	void *kaddr;

	int ret;



	down_read(&NILFS_MDT(cpfile)->mi_sem);
@@ -1087,12 +1117,11 @@ int nilfs_cpfile_get_stat(struct inode *cpfile, struct nilfs_cpstat *cpstat) 
	ret = nilfs_cpfile_get_header_block(cpfile, &bh);

	if (ret < 0)

		goto out_sem;

	kaddr = kmap_local_page(bh->b_page);

	header = nilfs_cpfile_block_get_header(cpfile, bh, kaddr);

	header = kmap_local_folio(bh->b_folio, 0);

	cpstat->cs_cno = nilfs_mdt_cno(cpfile);

	cpstat->cs_ncps = le64_to_cpu(header->ch_ncheckpoints);

	cpstat->cs_nsss = le64_to_cpu(header->ch_nsnapshots);

	kunmap_local(kaddr);

	kunmap_local(header);

	brelse(bh);



 out_sem: