Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 8707df38478c8e0958b706f0ea1cdf99d00a9469

Authored by Ryusuke Konishi 2009-11-13 00:36:56 +0800

Exists in master and in 7 other branches

nilfs2: separate read method of meta data files on super root block

Will displace nilfs_mdt_read_inode_direct function with an individual
read method: nilfs_dat_read, nilfs_sufile_read, nilfs_cpfile_read.

This provides the opportunity to initialize local variables of each
metadata file after reading the inode.

Signed-off-by: Ryusuke Konishi <konishi.ryusuke@lab.ntt.co.jp>

Showing 7 changed files with 39 additions and 6 deletions Inline Diff

fs/nilfs2/cpfile.c
fs/nilfs2/cpfile.h
fs/nilfs2/dat.c
fs/nilfs2/dat.h
fs/nilfs2/sufile.c
fs/nilfs2/sufile.h
fs/nilfs2/the_nilfs.c

fs/nilfs2/cpfile.c

Diff comments View file @ 8707df3

 /*
  * cpfile.c - NILFS checkpoint file.
  *
  * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  * Written by Koji Sato <koji@osrg.net>.
  */
 #include <linux/kernel.h>
 #include <linux/fs.h>
 #include <linux/string.h>
 #include <linux/buffer_head.h>
 #include <linux/errno.h>
 #include <linux/nilfs2_fs.h>
 #include "mdt.h"
 #include "cpfile.h"
 static inline unsigned long
 nilfs_cpfile_checkpoints_per_block(const struct inode *cpfile)
 {
 	return NILFS_MDT(cpfile)->mi_entries_per_block;
 }
 /* block number from the beginning of the file */
 static unsigned long
 nilfs_cpfile_get_blkoff(const struct inode *cpfile, __u64 cno)
 {
 	__u64 tcno = cno + NILFS_MDT(cpfile)->mi_first_entry_offset - 1;
 	do_div(tcno, nilfs_cpfile_checkpoints_per_block(cpfile));
 	return (unsigned long)tcno;
 }
 /* offset in block */
 static unsigned long
 nilfs_cpfile_get_offset(const struct inode *cpfile, __u64 cno)
 {
 	__u64 tcno = cno + NILFS_MDT(cpfile)->mi_first_entry_offset - 1;
 	return do_div(tcno, nilfs_cpfile_checkpoints_per_block(cpfile));
 }
 static unsigned long
 nilfs_cpfile_checkpoints_in_block(const struct inode *cpfile,
 				  __u64 curr,
 				  __u64 max)
 {
 	return min_t(__u64,
 		     nilfs_cpfile_checkpoints_per_block(cpfile) -
 		     nilfs_cpfile_get_offset(cpfile, curr),
 		     max - curr);
 }
 static inline int nilfs_cpfile_is_in_first(const struct inode *cpfile,
 					   __u64 cno)
 {
 	return nilfs_cpfile_get_blkoff(cpfile, cno) == 0;
 }
 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);
 	unsigned int count;
 	count = le32_to_cpu(cp->cp_checkpoints_count) + n;
 	cp->cp_checkpoints_count = cpu_to_le32(count);
 	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);
 	unsigned int count;
 	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);
 	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 *kaddr)
 {
 	struct nilfs_checkpoint *cp = kaddr + bh_offset(bh);
 	size_t cpsz = NILFS_MDT(cpfile)->mi_entry_size;
 	int n = nilfs_cpfile_checkpoints_per_block(cpfile);
 	while (n-- > 0) {
 		nilfs_checkpoint_set_invalid(cp);
 		cp = (void *)cp + cpsz;
 	}
 }
 static inline int nilfs_cpfile_get_header_block(struct inode *cpfile,
 						struct buffer_head **bhp)
 {
 	return nilfs_mdt_get_block(cpfile, 0, 0, NULL, bhp);
 }
 static inline int nilfs_cpfile_get_checkpoint_block(struct inode *cpfile,
 						    __u64 cno,
 						    int create,
 						    struct buffer_head **bhp)
 {
 	return nilfs_mdt_get_block(cpfile,
 				   nilfs_cpfile_get_blkoff(cpfile, cno),
 				   create, nilfs_cpfile_block_init, bhp);
 }
 static inline int nilfs_cpfile_delete_checkpoint_block(struct inode *cpfile,
 						       __u64 cno)
 {
 	return nilfs_mdt_delete_block(cpfile,
 				      nilfs_cpfile_get_blkoff(cpfile, cno));
 }
 /**
  * nilfs_cpfile_get_checkpoint - get a checkpoint
  * @cpfile: inode of checkpoint file
  * @cno: checkpoint number
  * @create: create flag
  * @cpp: pointer to a checkpoint
  * @bhp: pointer to a buffer head
  *
  * Description: nilfs_cpfile_get_checkpoint() acquires the checkpoint
  * specified by @cno. A new checkpoint will be created if @cno is the current
  * checkpoint number and @create is nonzero.
  *
  * Return Value: On success, 0 is returned, and the checkpoint and the
  * buffer head of the buffer on which the checkpoint is located are stored in
  * the place pointed by @cpp and @bhp, respectively. On error, one of the
  * following negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  *
  * %-ENOENT - No such checkpoint.
  *
  * %-EINVAL - invalid checkpoint.
  */
 int nilfs_cpfile_get_checkpoint(struct inode *cpfile,
 				__u64 cno,
 				int create,
 				struct nilfs_checkpoint **cpp,
 				struct buffer_head **bhp)
 {
 	struct buffer_head *header_bh, *cp_bh;
 	struct nilfs_cpfile_header *header;
 	struct nilfs_checkpoint *cp;
 	void *kaddr;
 	int ret;
 	if (unlikely(cno < 1 || cno > nilfs_mdt_cno(cpfile) ||
 		     (cno < nilfs_mdt_cno(cpfile) && create)))
 		return -EINVAL;
 	down_write(&NILFS_MDT(cpfile)->mi_sem);
 	ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);
 	if (ret < 0)
 		goto out_sem;
 	ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, create, &cp_bh);
 	if (ret < 0)
 		goto out_header;
 	kaddr = kmap(cp_bh->b_page);
 	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
 	if (nilfs_checkpoint_invalid(cp)) {
 		if (!create) {
 			kunmap(cp_bh->b_page);
 			brelse(cp_bh);
 			ret = -ENOENT;
 			goto out_header;
 		}
 		/* a newly-created checkpoint */
 		nilfs_checkpoint_clear_invalid(cp);
 		if (!nilfs_cpfile_is_in_first(cpfile, cno))
 			nilfs_cpfile_block_add_valid_checkpoints(cpfile, cp_bh,
 								 kaddr, 1);
 		nilfs_mdt_mark_buffer_dirty(cp_bh);
 		kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
 		header = nilfs_cpfile_block_get_header(cpfile, header_bh,
 						       kaddr);
 		le64_add_cpu(&header->ch_ncheckpoints, 1);
 		kunmap_atomic(kaddr, KM_USER0);
 		nilfs_mdt_mark_buffer_dirty(header_bh);
 		nilfs_mdt_mark_dirty(cpfile);
 	}
 	if (cpp != NULL)
 		*cpp = cp;
 	*bhp = cp_bh;
  out_header:
 	brelse(header_bh);
  out_sem:
 	up_write(&NILFS_MDT(cpfile)->mi_sem);
 	return ret;
 }
 /**
  * nilfs_cpfile_put_checkpoint - put a checkpoint
  * @cpfile: inode of checkpoint file
  * @cno: checkpoint number
  * @bh: buffer head
  *
  * Description: nilfs_cpfile_put_checkpoint() releases the checkpoint
  * specified by @cno. @bh must be the buffer head which has been returned by
  * a previous call to nilfs_cpfile_get_checkpoint() with @cno.
  */
 void nilfs_cpfile_put_checkpoint(struct inode *cpfile, __u64 cno,
 				 struct buffer_head *bh)
 {
 	kunmap(bh->b_page);
 	brelse(bh);
 }
 /**
  * nilfs_cpfile_delete_checkpoints - delete checkpoints
  * @cpfile: inode of checkpoint file
  * @start: start checkpoint number
  * @end: end checkpoint numer
  *
  * Description: nilfs_cpfile_delete_checkpoints() deletes the checkpoints in
  * the period from @start to @end, excluding @end itself. The checkpoints
  * which have been already deleted are ignored.
  *
  * Return Value: On success, 0 is returned. On error, one of the following
  * negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  *
  * %-EINVAL - invalid checkpoints.
  */
 int nilfs_cpfile_delete_checkpoints(struct inode *cpfile,
 				    __u64 start,
 				    __u64 end)
 {
 	struct buffer_head *header_bh, *cp_bh;
 	struct nilfs_cpfile_header *header;
 	struct nilfs_checkpoint *cp;
 	size_t cpsz = NILFS_MDT(cpfile)->mi_entry_size;
 	__u64 cno;
 	void *kaddr;
 	unsigned long tnicps;
 	int ret, ncps, nicps, count, i;
 	if (unlikely(start == 0 || start > end)) {
 		printk(KERN_ERR "%s: invalid range of checkpoint numbers: "
 		       "[%llu, %llu)\n", __func__,
 		       (unsigned long long)start, (unsigned long long)end);
 		return -EINVAL;
 	}
 	down_write(&NILFS_MDT(cpfile)->mi_sem);
 	ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);
 	if (ret < 0)
 		goto out_sem;
 	tnicps = 0;
 	for (cno = start; cno < end; cno += ncps) {
 		ncps = nilfs_cpfile_checkpoints_in_block(cpfile, cno, end);
 		ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &cp_bh);
 		if (ret < 0) {
 			if (ret != -ENOENT)
 				break;
 			/* skip hole */
 			ret = 0;
 			continue;
 		}
 		kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
 		cp = nilfs_cpfile_block_get_checkpoint(
 			cpfile, cno, cp_bh, kaddr);
 		nicps = 0;
 		for (i = 0; i < ncps; i++, cp = (void *)cp + cpsz) {
 			WARN_ON(nilfs_checkpoint_snapshot(cp));
 			if (!nilfs_checkpoint_invalid(cp)) {
 				nilfs_checkpoint_set_invalid(cp);
 				nicps++;
 			}
 		}
 		if (nicps > 0) {
 			tnicps += nicps;
 			nilfs_mdt_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)) == 0) {
 				/* make hole */
 				kunmap_atomic(kaddr, KM_USER0);
 				brelse(cp_bh);
 				ret = nilfs_cpfile_delete_checkpoint_block(
 					cpfile, cno);
 				if (ret == 0)
 					continue;
 				printk(KERN_ERR "%s: cannot delete block\n",
 				       __func__);
 				break;
 			}
 		}
 		kunmap_atomic(kaddr, KM_USER0);
 		brelse(cp_bh);
 	}
 	if (tnicps > 0) {
 		kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
 		header = nilfs_cpfile_block_get_header(cpfile, header_bh,
 						       kaddr);
 		le64_add_cpu(&header->ch_ncheckpoints, -(u64)tnicps);
 		nilfs_mdt_mark_buffer_dirty(header_bh);
 		nilfs_mdt_mark_dirty(cpfile);
 		kunmap_atomic(kaddr, KM_USER0);
 	}
 	brelse(header_bh);
  out_sem:
 	up_write(&NILFS_MDT(cpfile)->mi_sem);
 	return ret;
 }
 static void nilfs_cpfile_checkpoint_to_cpinfo(struct inode *cpfile,
 					      struct nilfs_checkpoint *cp,
 					      struct nilfs_cpinfo *ci)
 {
 	ci->ci_flags = le32_to_cpu(cp->cp_flags);
 	ci->ci_cno = le64_to_cpu(cp->cp_cno);
 	ci->ci_create = le64_to_cpu(cp->cp_create);
 	ci->ci_nblk_inc = le64_to_cpu(cp->cp_nblk_inc);
 	ci->ci_inodes_count = le64_to_cpu(cp->cp_inodes_count);
 	ci->ci_blocks_count = le64_to_cpu(cp->cp_blocks_count);
 	ci->ci_next = le64_to_cpu(cp->cp_snapshot_list.ssl_next);
 }
 static ssize_t nilfs_cpfile_do_get_cpinfo(struct inode *cpfile, __u64 *cnop,
 					  void *buf, unsigned cisz, size_t nci)
 {
 	struct nilfs_checkpoint *cp;
 	struct nilfs_cpinfo *ci = buf;
 	struct buffer_head *bh;
 	size_t cpsz = NILFS_MDT(cpfile)->mi_entry_size;
 	__u64 cur_cno = nilfs_mdt_cno(cpfile), cno = *cnop;
 	void *kaddr;
 	int n, ret;
 	int ncps, i;
 	if (cno == 0)
 		return -ENOENT; /* checkpoint number 0 is invalid */
 	down_read(&NILFS_MDT(cpfile)->mi_sem);
 	for (n = 0; cno < cur_cno && n < nci; cno += ncps) {
 		ncps = nilfs_cpfile_checkpoints_in_block(cpfile, cno, cur_cno);
 		ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &bh);
 		if (ret < 0) {
 			if (ret != -ENOENT)
 				goto out;
 			continue; /* skip hole */
 		}
 		kaddr = kmap_atomic(bh->b_page, KM_USER0);
 		cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, bh, kaddr);
 		for (i = 0; i < ncps && n < nci; i++, cp = (void *)cp + cpsz) {
 			if (!nilfs_checkpoint_invalid(cp)) {
 				nilfs_cpfile_checkpoint_to_cpinfo(cpfile, cp,
 								  ci);
 				ci = (void *)ci + cisz;
 				n++;
 			}
 		}
 		kunmap_atomic(kaddr, KM_USER0);
 		brelse(bh);
 	}
 	ret = n;
 	if (n > 0) {
 		ci = (void *)ci - cisz;
 		*cnop = ci->ci_cno + 1;
 	}
  out:
 	up_read(&NILFS_MDT(cpfile)->mi_sem);
 	return ret;
 }
 static ssize_t nilfs_cpfile_do_get_ssinfo(struct inode *cpfile, __u64 *cnop,
 					  void *buf, unsigned cisz, size_t nci)
 {
 	struct buffer_head *bh;
 	struct nilfs_cpfile_header *header;
 	struct nilfs_checkpoint *cp;
 	struct nilfs_cpinfo *ci = buf;
 	__u64 curr = *cnop, next;
 	unsigned long curr_blkoff, next_blkoff;
 	void *kaddr;
 	int n = 0, ret;
 	down_read(&NILFS_MDT(cpfile)->mi_sem);
 	if (curr == 0) {
 		ret = nilfs_cpfile_get_header_block(cpfile, &bh);
 		if (ret < 0)
 			goto out;
 		kaddr = kmap_atomic(bh->b_page, KM_USER0);
 		header = nilfs_cpfile_block_get_header(cpfile, bh, kaddr);
 		curr = le64_to_cpu(header->ch_snapshot_list.ssl_next);
 		kunmap_atomic(kaddr, KM_USER0);
 		brelse(bh);
 		if (curr == 0) {
 			ret = 0;
 			goto out;
 		}
 	} else if (unlikely(curr == ~(__u64)0)) {
 		ret = 0;
 		goto out;
 	}
 	curr_blkoff = nilfs_cpfile_get_blkoff(cpfile, curr);
 	ret = nilfs_cpfile_get_checkpoint_block(cpfile, curr, 0, &bh);
 	if (unlikely(ret < 0)) {
 		if (ret == -ENOENT)
 			ret = 0; /* No snapshots (started from a hole block) */
 		goto out;
 	}
 	kaddr = kmap_atomic(bh->b_page, KM_USER0);
 	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)))
 			break;
 		nilfs_cpfile_checkpoint_to_cpinfo(cpfile, cp, ci);
 		ci = (void *)ci + cisz;
 		n++;
 		next = le64_to_cpu(cp->cp_snapshot_list.ssl_next);
 		if (next == 0)
 			break; /* reach end of the snapshot list */
 		next_blkoff = nilfs_cpfile_get_blkoff(cpfile, next);
 		if (curr_blkoff != next_blkoff) {
 			kunmap_atomic(kaddr, KM_USER0);
 			brelse(bh);
 			ret = nilfs_cpfile_get_checkpoint_block(cpfile, next,
 								0, &bh);
 			if (unlikely(ret < 0)) {
 				WARN_ON(ret == -ENOENT);
 				goto out;
 			}
 			kaddr = kmap_atomic(bh->b_page, KM_USER0);
 		}
 		curr = next;
 		curr_blkoff = next_blkoff;
 	}
 	kunmap_atomic(kaddr, KM_USER0);
 	brelse(bh);
 	*cnop = curr;
 	ret = n;
  out:
 	up_read(&NILFS_MDT(cpfile)->mi_sem);
 	return ret;
 }
 /**
  * nilfs_cpfile_get_cpinfo -
  * @cpfile:
  * @cno:
  * @ci:
  * @nci:
  */
 ssize_t nilfs_cpfile_get_cpinfo(struct inode *cpfile, __u64 *cnop, int mode,
 				void *buf, unsigned cisz, size_t nci)
 {
 	switch (mode) {
 	case NILFS_CHECKPOINT:
 		return nilfs_cpfile_do_get_cpinfo(cpfile, cnop, buf, cisz, nci);
 	case NILFS_SNAPSHOT:
 		return nilfs_cpfile_do_get_ssinfo(cpfile, cnop, buf, cisz, nci);
 	default:
 		return -EINVAL;
 	}
 }
 /**
  * nilfs_cpfile_delete_checkpoint -
  * @cpfile:
  * @cno:
  */
 int nilfs_cpfile_delete_checkpoint(struct inode *cpfile, __u64 cno)
 {
 	struct nilfs_cpinfo ci;
 	__u64 tcno = cno;
 	ssize_t nci;
 	nci = nilfs_cpfile_do_get_cpinfo(cpfile, &tcno, &ci, sizeof(ci), 1);
 	if (nci < 0)
 		return nci;
 	else if (nci == 0 || ci.ci_cno != cno)
 		return -ENOENT;
 	else if (nilfs_cpinfo_snapshot(&ci))
 		return -EBUSY;
 	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;
 	struct nilfs_cpfile_header *header;
 	struct nilfs_checkpoint *cp;
 	struct nilfs_snapshot_list *list;
 	__u64 curr, prev;
 	unsigned long curr_blkoff, prev_blkoff;
 	void *kaddr;
 	int ret;
 	if (cno == 0)
 		return -ENOENT; /* checkpoint number 0 is invalid */
 	down_write(&NILFS_MDT(cpfile)->mi_sem);
 	ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &cp_bh);
 	if (ret < 0)
 		goto out_sem;
 	kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
 	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
 	if (nilfs_checkpoint_invalid(cp)) {
 		ret = -ENOENT;
 		kunmap_atomic(kaddr, KM_USER0);
 		goto out_cp;
 	}
 	if (nilfs_checkpoint_snapshot(cp)) {
 		ret = 0;
 		kunmap_atomic(kaddr, KM_USER0);
 		goto out_cp;
 	}
 	kunmap_atomic(kaddr, KM_USER0);
 	ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);
 	if (ret < 0)
 		goto out_cp;
 	kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
 	header = nilfs_cpfile_block_get_header(cpfile, header_bh, kaddr);
 	list = &header->ch_snapshot_list;
 	curr_bh = header_bh;
 	get_bh(curr_bh);
 	curr = 0;
 	curr_blkoff = 0;
 	prev = le64_to_cpu(list->ssl_prev);
 	while (prev > cno) {
 		prev_blkoff = nilfs_cpfile_get_blkoff(cpfile, prev);
 		curr = prev;
 		if (curr_blkoff != prev_blkoff) {
 			kunmap_atomic(kaddr, KM_USER0);
 			brelse(curr_bh);
 			ret = nilfs_cpfile_get_checkpoint_block(cpfile, curr,
 								0, &curr_bh);
 			if (ret < 0)
 				goto out_header;
 			kaddr = kmap_atomic(curr_bh->b_page, KM_USER0);
 		}
 		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_atomic(kaddr, KM_USER0);
 	if (prev != 0) {
 		ret = nilfs_cpfile_get_checkpoint_block(cpfile, prev, 0,
 							&prev_bh);
 		if (ret < 0)
 			goto out_curr;
 	} else {
 		prev_bh = header_bh;
 		get_bh(prev_bh);
 	}
 	kaddr = kmap_atomic(curr_bh->b_page, KM_USER0);
 	list = nilfs_cpfile_block_get_snapshot_list(
 		cpfile, curr, curr_bh, kaddr);
 	list->ssl_prev = cpu_to_le64(cno);
 	kunmap_atomic(kaddr, KM_USER0);
 	kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
 	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
 	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_atomic(kaddr, KM_USER0);
 	kaddr = kmap_atomic(prev_bh->b_page, KM_USER0);
 	list = nilfs_cpfile_block_get_snapshot_list(
 		cpfile, prev, prev_bh, kaddr);
 	list->ssl_next = cpu_to_le64(cno);
 	kunmap_atomic(kaddr, KM_USER0);
 	kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
 	header = nilfs_cpfile_block_get_header(cpfile, header_bh, kaddr);
 	le64_add_cpu(&header->ch_nsnapshots, 1);
 	kunmap_atomic(kaddr, KM_USER0);
 	nilfs_mdt_mark_buffer_dirty(prev_bh);
 	nilfs_mdt_mark_buffer_dirty(curr_bh);
 	nilfs_mdt_mark_buffer_dirty(cp_bh);
 	nilfs_mdt_mark_buffer_dirty(header_bh);
 	nilfs_mdt_mark_dirty(cpfile);
 	brelse(prev_bh);
  out_curr:
 	brelse(curr_bh);
  out_header:
 	brelse(header_bh);
  out_cp:
 	brelse(cp_bh);
  out_sem:
 	up_write(&NILFS_MDT(cpfile)->mi_sem);
 	return ret;
 }
 static int nilfs_cpfile_clear_snapshot(struct inode *cpfile, __u64 cno)
 {
 	struct buffer_head *header_bh, *next_bh, *prev_bh, *cp_bh;
 	struct nilfs_cpfile_header *header;
 	struct nilfs_checkpoint *cp;
 	struct nilfs_snapshot_list *list;
 	__u64 next, prev;
 	void *kaddr;
 	int ret;
 	if (cno == 0)
 		return -ENOENT; /* checkpoint number 0 is invalid */
 	down_write(&NILFS_MDT(cpfile)->mi_sem);
 	ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &cp_bh);
 	if (ret < 0)
 		goto out_sem;
 	kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
 	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
 	if (nilfs_checkpoint_invalid(cp)) {
 		ret = -ENOENT;
 		kunmap_atomic(kaddr, KM_USER0);
 		goto out_cp;
 	}
 	if (!nilfs_checkpoint_snapshot(cp)) {
 		ret = 0;
 		kunmap_atomic(kaddr, KM_USER0);
 		goto out_cp;
 	}
 	list = &cp->cp_snapshot_list;
 	next = le64_to_cpu(list->ssl_next);
 	prev = le64_to_cpu(list->ssl_prev);
 	kunmap_atomic(kaddr, KM_USER0);
 	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;
 	} else {
 		next_bh = header_bh;
 		get_bh(next_bh);
 	}
 	if (prev != 0) {
 		ret = nilfs_cpfile_get_checkpoint_block(cpfile, prev, 0,
 							&prev_bh);
 		if (ret < 0)
 			goto out_next;
 	} else {
 		prev_bh = header_bh;
 		get_bh(prev_bh);
 	}
 	kaddr = kmap_atomic(next_bh->b_page, KM_USER0);
 	list = nilfs_cpfile_block_get_snapshot_list(
 		cpfile, next, next_bh, kaddr);
 	list->ssl_prev = cpu_to_le64(prev);
 	kunmap_atomic(kaddr, KM_USER0);
 	kaddr = kmap_atomic(prev_bh->b_page, KM_USER0);
 	list = nilfs_cpfile_block_get_snapshot_list(
 		cpfile, prev, prev_bh, kaddr);
 	list->ssl_next = cpu_to_le64(next);
 	kunmap_atomic(kaddr, KM_USER0);
 	kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
 	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
 	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_atomic(kaddr, KM_USER0);
 	kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
 	header = nilfs_cpfile_block_get_header(cpfile, header_bh, kaddr);
 	le64_add_cpu(&header->ch_nsnapshots, -1);
 	kunmap_atomic(kaddr, KM_USER0);
 	nilfs_mdt_mark_buffer_dirty(next_bh);
 	nilfs_mdt_mark_buffer_dirty(prev_bh);
 	nilfs_mdt_mark_buffer_dirty(cp_bh);
 	nilfs_mdt_mark_buffer_dirty(header_bh);
 	nilfs_mdt_mark_dirty(cpfile);
 	brelse(prev_bh);
  out_next:
 	brelse(next_bh);
  out_header:
 	brelse(header_bh);
  out_cp:
 	brelse(cp_bh);
  out_sem:
 	up_write(&NILFS_MDT(cpfile)->mi_sem);
 	return ret;
 }
 /**
  * nilfs_cpfile_is_snapshot -
  * @cpfile: inode of checkpoint file
  * @cno: checkpoint number
  *
  * Description:
  *
  * Return Value: On success, 1 is returned if the checkpoint specified by
  * @cno is a snapshot, or 0 if not. On error, one of the following negative
  * error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  *
  * %-ENOENT - No such checkpoint.
  */
 int nilfs_cpfile_is_snapshot(struct inode *cpfile, __u64 cno)
 {
 	struct buffer_head *bh;
 	struct nilfs_checkpoint *cp;
 	void *kaddr;
 	int ret;
 	/* CP number is invalid if it's zero or larger than the
 	largest	exist one.*/
 	if (cno == 0 || cno >= nilfs_mdt_cno(cpfile))
 		return -ENOENT;
 	down_read(&NILFS_MDT(cpfile)->mi_sem);
 	ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &bh);
 	if (ret < 0)
 		goto out;
 	kaddr = kmap_atomic(bh->b_page, KM_USER0);
 	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, bh, kaddr);
 	if (nilfs_checkpoint_invalid(cp))
 		ret = -ENOENT;
 	else
 		ret = nilfs_checkpoint_snapshot(cp);
 	kunmap_atomic(kaddr, KM_USER0);
 	brelse(bh);
  out:
 	up_read(&NILFS_MDT(cpfile)->mi_sem);
 	return ret;
 }
 /**
  * nilfs_cpfile_change_cpmode - change checkpoint mode
  * @cpfile: inode of checkpoint file
  * @cno: checkpoint number
  * @status: mode of checkpoint
  *
  * Description: nilfs_change_cpmode() changes the mode of the checkpoint
  * specified by @cno. The mode @mode is NILFS_CHECKPOINT or NILFS_SNAPSHOT.
  *
  * Return Value: On success, 0 is returned. On error, one of the following
  * negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  *
  * %-ENOENT - No such checkpoint.
  */
 int nilfs_cpfile_change_cpmode(struct inode *cpfile, __u64 cno, int mode)
 {
 	struct the_nilfs *nilfs;
 	int ret;
 	nilfs = NILFS_MDT(cpfile)->mi_nilfs;
 	switch (mode) {
 	case NILFS_CHECKPOINT:
 		/*
 		 * Check for protecting existing snapshot mounts:
 		 * ns_mount_mutex is used to make this operation atomic and
 		 * exclusive with a new mount job.  Though it doesn't cover
 		 * umount, it's enough for the purpose.
 		 */
 		if (nilfs_checkpoint_is_mounted(nilfs, cno, 1)) {
 			/* Current implementation does not have to protect
 			   plain read-only mounts since they are exclusive
 			   with a read/write mount and are protected from the
 			   cleaner. */
 			ret = -EBUSY;
 		} else
 			ret = nilfs_cpfile_clear_snapshot(cpfile, cno);
 		return ret;
 	case NILFS_SNAPSHOT:
 		return nilfs_cpfile_set_snapshot(cpfile, cno);
 	default:
 		return -EINVAL;
 	}
 }
 /**
  * nilfs_cpfile_get_stat - get checkpoint statistics
  * @cpfile: inode of checkpoint file
  * @stat: pointer to a structure of checkpoint statistics
  *
  * Description: nilfs_cpfile_get_stat() returns information about checkpoints.
  *
  * Return Value: On success, 0 is returned, and checkpoints information is
  * stored in the place pointed by @stat. On error, one of the following
  * negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  */
 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);
 	ret = nilfs_cpfile_get_header_block(cpfile, &bh);
 	if (ret < 0)
 		goto out_sem;
 	kaddr = kmap_atomic(bh->b_page, KM_USER0);
 	header = nilfs_cpfile_block_get_header(cpfile, bh, kaddr);
 	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_atomic(kaddr, KM_USER0);
 	brelse(bh);
  out_sem:
 	up_read(&NILFS_MDT(cpfile)->mi_sem);
 	return ret;
 }
 /**
+ * nilfs_cpfile_read - read cpfile inode
+ * @cpfile: cpfile inode
+ * @raw_inode: on-disk cpfile inode
+ */
+int nilfs_cpfile_read(struct inode *cpfile, struct nilfs_inode *raw_inode)
+{
+	return nilfs_read_inode_common(cpfile, raw_inode);
+}
+/**
  * nilfs_cpfile_new - create cpfile
  * @nilfs: nilfs object
  * @cpsize: size of a checkpoint entry
  */
 struct inode *nilfs_cpfile_new(struct the_nilfs *nilfs, size_t cpsize)
 {
 	struct inode *cpfile;
 	cpfile = nilfs_mdt_new(nilfs, NULL, NILFS_CPFILE_INO, 0);
 	if (cpfile)
 		nilfs_mdt_set_entry_size(cpfile, cpsize,
 					 sizeof(struct nilfs_cpfile_header));
 	return cpfile;
 }

fs/nilfs2/cpfile.h

Diff comments View file @ 8707df3

 /*
  * cpfile.h - NILFS checkpoint file.
  *
  * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  * Written by Koji Sato <koji@osrg.net>.
  */
 #ifndef _NILFS_CPFILE_H
 #define _NILFS_CPFILE_H
 #include <linux/fs.h>
 #include <linux/buffer_head.h>
 #include <linux/nilfs2_fs.h>
 int nilfs_cpfile_get_checkpoint(struct inode *, __u64, int,
 				struct nilfs_checkpoint **,
 				struct buffer_head **);
 void nilfs_cpfile_put_checkpoint(struct inode *, __u64, struct buffer_head *);
 int nilfs_cpfile_delete_checkpoints(struct inode *, __u64, __u64);
 int nilfs_cpfile_delete_checkpoint(struct inode *, __u64);
 int nilfs_cpfile_change_cpmode(struct inode *, __u64, int);
 int nilfs_cpfile_is_snapshot(struct inode *, __u64);
 int nilfs_cpfile_get_stat(struct inode *, struct nilfs_cpstat *);
 ssize_t nilfs_cpfile_get_cpinfo(struct inode *, __u64 *, int, void *, unsigned,
 				size_t);
+int nilfs_cpfile_read(struct inode *cpfile, struct nilfs_inode *raw_inode);
 struct inode *nilfs_cpfile_new(struct the_nilfs *nilfs, size_t cpsize);
 #endif	/* _NILFS_CPFILE_H */

fs/nilfs2/dat.c

Diff comments View file @ 8707df3

 /*
  * dat.c - NILFS disk address translation.
  *
  * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  * Written by Koji Sato <koji@osrg.net>.
  */
 #include <linux/types.h>
 #include <linux/buffer_head.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include "nilfs.h"
 #include "mdt.h"
 #include "alloc.h"
 #include "dat.h"
 #define NILFS_CNO_MIN	((__u64)1)
 #define NILFS_CNO_MAX	(~(__u64)0)
 static int nilfs_dat_prepare_entry(struct inode *dat,
 				   struct nilfs_palloc_req *req, int create)
 {
 	return nilfs_palloc_get_entry_block(dat, req->pr_entry_nr,
 					    create, &req->pr_entry_bh);
 }
 static void nilfs_dat_commit_entry(struct inode *dat,
 				   struct nilfs_palloc_req *req)
 {
 	nilfs_mdt_mark_buffer_dirty(req->pr_entry_bh);
 	nilfs_mdt_mark_dirty(dat);
 	brelse(req->pr_entry_bh);
 }
 static void nilfs_dat_abort_entry(struct inode *dat,
 				  struct nilfs_palloc_req *req)
 {
 	brelse(req->pr_entry_bh);
 }
 int nilfs_dat_prepare_alloc(struct inode *dat, struct nilfs_palloc_req *req)
 {
 	int ret;
 	ret = nilfs_palloc_prepare_alloc_entry(dat, req);
 	if (ret < 0)
 		return ret;
 	ret = nilfs_dat_prepare_entry(dat, req, 1);
 	if (ret < 0)
 		nilfs_palloc_abort_alloc_entry(dat, req);
 	return ret;
 }
 void nilfs_dat_commit_alloc(struct inode *dat, struct nilfs_palloc_req *req)
 {
 	struct nilfs_dat_entry *entry;
 	void *kaddr;
 	kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
 	entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
 					     req->pr_entry_bh, kaddr);
 	entry->de_start = cpu_to_le64(NILFS_CNO_MIN);
 	entry->de_end = cpu_to_le64(NILFS_CNO_MAX);
 	entry->de_blocknr = cpu_to_le64(0);
 	kunmap_atomic(kaddr, KM_USER0);
 	nilfs_palloc_commit_alloc_entry(dat, req);
 	nilfs_dat_commit_entry(dat, req);
 }
 void nilfs_dat_abort_alloc(struct inode *dat, struct nilfs_palloc_req *req)
 {
 	nilfs_dat_abort_entry(dat, req);
 	nilfs_palloc_abort_alloc_entry(dat, req);
 }
 void nilfs_dat_commit_free(struct inode *dat, struct nilfs_palloc_req *req)
 {
 	struct nilfs_dat_entry *entry;
 	void *kaddr;
 	kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
 	entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
 					     req->pr_entry_bh, kaddr);
 	entry->de_start = cpu_to_le64(NILFS_CNO_MIN);
 	entry->de_end = cpu_to_le64(NILFS_CNO_MIN);
 	entry->de_blocknr = cpu_to_le64(0);
 	kunmap_atomic(kaddr, KM_USER0);
 	nilfs_dat_commit_entry(dat, req);
 	nilfs_palloc_commit_free_entry(dat, req);
 }
 int nilfs_dat_prepare_start(struct inode *dat, struct nilfs_palloc_req *req)
 {
 	int ret;
 	ret = nilfs_dat_prepare_entry(dat, req, 0);
 	WARN_ON(ret == -ENOENT);
 	return ret;
 }
 void nilfs_dat_commit_start(struct inode *dat, struct nilfs_palloc_req *req,
 			    sector_t blocknr)
 {
 	struct nilfs_dat_entry *entry;
 	void *kaddr;
 	kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
 	entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
 					     req->pr_entry_bh, kaddr);
 	entry->de_start = cpu_to_le64(nilfs_mdt_cno(dat));
 	entry->de_blocknr = cpu_to_le64(blocknr);
 	kunmap_atomic(kaddr, KM_USER0);
 	nilfs_dat_commit_entry(dat, req);
 }
 int nilfs_dat_prepare_end(struct inode *dat, struct nilfs_palloc_req *req)
 {
 	struct nilfs_dat_entry *entry;
 	__u64 start;
 	sector_t blocknr;
 	void *kaddr;
 	int ret;
 	ret = nilfs_dat_prepare_entry(dat, req, 0);
 	if (ret < 0) {
 		WARN_ON(ret == -ENOENT);
 		return ret;
 	}
 	kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
 	entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
 					     req->pr_entry_bh, kaddr);
 	start = le64_to_cpu(entry->de_start);
 	blocknr = le64_to_cpu(entry->de_blocknr);
 	kunmap_atomic(kaddr, KM_USER0);
 	if (blocknr == 0) {
 		ret = nilfs_palloc_prepare_free_entry(dat, req);
 		if (ret < 0) {
 			nilfs_dat_abort_entry(dat, req);
 			return ret;
 		}
 	}
 	return 0;
 }
 void nilfs_dat_commit_end(struct inode *dat, struct nilfs_palloc_req *req,
 			  int dead)
 {
 	struct nilfs_dat_entry *entry;
 	__u64 start, end;
 	sector_t blocknr;
 	void *kaddr;
 	kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
 	entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
 					     req->pr_entry_bh, kaddr);
 	end = start = le64_to_cpu(entry->de_start);
 	if (!dead) {
 		end = nilfs_mdt_cno(dat);
 		WARN_ON(start > end);
 	}
 	entry->de_end = cpu_to_le64(end);
 	blocknr = le64_to_cpu(entry->de_blocknr);
 	kunmap_atomic(kaddr, KM_USER0);
 	if (blocknr == 0)
 		nilfs_dat_commit_free(dat, req);
 	else
 		nilfs_dat_commit_entry(dat, req);
 }
 void nilfs_dat_abort_end(struct inode *dat, struct nilfs_palloc_req *req)
 {
 	struct nilfs_dat_entry *entry;
 	__u64 start;
 	sector_t blocknr;
 	void *kaddr;
 	kaddr = kmap_atomic(req->pr_entry_bh->b_page, KM_USER0);
 	entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
 					     req->pr_entry_bh, kaddr);
 	start = le64_to_cpu(entry->de_start);
 	blocknr = le64_to_cpu(entry->de_blocknr);
 	kunmap_atomic(kaddr, KM_USER0);
 	if (start == nilfs_mdt_cno(dat) && blocknr == 0)
 		nilfs_palloc_abort_free_entry(dat, req);
 	nilfs_dat_abort_entry(dat, req);
 }
 int nilfs_dat_prepare_update(struct inode *dat,
 			     struct nilfs_palloc_req *oldreq,
 			     struct nilfs_palloc_req *newreq)
 {
 	int ret;
 	ret = nilfs_dat_prepare_end(dat, oldreq);
 	if (!ret) {
 		ret = nilfs_dat_prepare_alloc(dat, newreq);
 		if (ret < 0)
 			nilfs_dat_abort_end(dat, oldreq);
 	}
 	return ret;
 }
 void nilfs_dat_commit_update(struct inode *dat,
 			     struct nilfs_palloc_req *oldreq,
 			     struct nilfs_palloc_req *newreq, int dead)
 {
 	nilfs_dat_commit_end(dat, oldreq, dead);
 	nilfs_dat_commit_alloc(dat, newreq);
 }
 void nilfs_dat_abort_update(struct inode *dat,
 			    struct nilfs_palloc_req *oldreq,
 			    struct nilfs_palloc_req *newreq)
 {
 	nilfs_dat_abort_end(dat, oldreq);
 	nilfs_dat_abort_alloc(dat, newreq);
 }
 /**
  * nilfs_dat_mark_dirty -
  * @dat: DAT file inode
  * @vblocknr: virtual block number
  *
  * Description:
  *
  * Return Value: On success, 0 is returned. On error, one of the following
  * negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  */
 int nilfs_dat_mark_dirty(struct inode *dat, __u64 vblocknr)
 {
 	struct nilfs_palloc_req req;
 	int ret;
 	req.pr_entry_nr = vblocknr;
 	ret = nilfs_dat_prepare_entry(dat, &req, 0);
 	if (ret == 0)
 		nilfs_dat_commit_entry(dat, &req);
 	return ret;
 }
 /**
  * nilfs_dat_freev - free virtual block numbers
  * @dat: DAT file inode
  * @vblocknrs: array of virtual block numbers
  * @nitems: number of virtual block numbers
  *
  * Description: nilfs_dat_freev() frees the virtual block numbers specified by
  * @vblocknrs and @nitems.
  *
  * Return Value: On success, 0 is returned. On error, one of the following
  * nagative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  *
  * %-ENOENT - The virtual block number have not been allocated.
  */
 int nilfs_dat_freev(struct inode *dat, __u64 *vblocknrs, size_t nitems)
 {
 	return nilfs_palloc_freev(dat, vblocknrs, nitems);
 }
 /**
  * nilfs_dat_move - change a block number
  * @dat: DAT file inode
  * @vblocknr: virtual block number
  * @blocknr: block number
  *
  * Description: nilfs_dat_move() changes the block number associated with
  * @vblocknr to @blocknr.
  *
  * Return Value: On success, 0 is returned. On error, one of the following
  * negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  */
 int nilfs_dat_move(struct inode *dat, __u64 vblocknr, sector_t blocknr)
 {
 	struct buffer_head *entry_bh;
 	struct nilfs_dat_entry *entry;
 	void *kaddr;
 	int ret;
 	ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh);
 	if (ret < 0)
 		return ret;
 	kaddr = kmap_atomic(entry_bh->b_page, KM_USER0);
 	entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr);
 	if (unlikely(entry->de_blocknr == cpu_to_le64(0))) {
 		printk(KERN_CRIT "%s: vbn = %llu, [%llu, %llu)\n", __func__,
 		       (unsigned long long)vblocknr,
 		       (unsigned long long)le64_to_cpu(entry->de_start),
 		       (unsigned long long)le64_to_cpu(entry->de_end));
 		kunmap_atomic(kaddr, KM_USER0);
 		brelse(entry_bh);
 		return -EINVAL;
 	}
 	WARN_ON(blocknr == 0);
 	entry->de_blocknr = cpu_to_le64(blocknr);
 	kunmap_atomic(kaddr, KM_USER0);
 	nilfs_mdt_mark_buffer_dirty(entry_bh);
 	nilfs_mdt_mark_dirty(dat);
 	brelse(entry_bh);
 	return 0;
 }
 /**
  * nilfs_dat_translate - translate a virtual block number to a block number
  * @dat: DAT file inode
  * @vblocknr: virtual block number
  * @blocknrp: pointer to a block number
  *
  * Description: nilfs_dat_translate() maps the virtual block number @vblocknr
  * to the corresponding block number.
  *
  * Return Value: On success, 0 is returned and the block number associated
  * with @vblocknr is stored in the place pointed by @blocknrp. On error, one
  * of the following negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  *
  * %-ENOENT - A block number associated with @vblocknr does not exist.
  */
 int nilfs_dat_translate(struct inode *dat, __u64 vblocknr, sector_t *blocknrp)
 {
 	struct buffer_head *entry_bh;
 	struct nilfs_dat_entry *entry;
 	sector_t blocknr;
 	void *kaddr;
 	int ret;
 	ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh);
 	if (ret < 0)
 		return ret;
 	kaddr = kmap_atomic(entry_bh->b_page, KM_USER0);
 	entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr);
 	blocknr = le64_to_cpu(entry->de_blocknr);
 	if (blocknr == 0) {
 		ret = -ENOENT;
 		goto out;
 	}
 	if (blocknrp != NULL)
 		*blocknrp = blocknr;
  out:
 	kunmap_atomic(kaddr, KM_USER0);
 	brelse(entry_bh);
 	return ret;
 }
 ssize_t nilfs_dat_get_vinfo(struct inode *dat, void *buf, unsigned visz,
 			    size_t nvi)
 {
 	struct buffer_head *entry_bh;
 	struct nilfs_dat_entry *entry;
 	struct nilfs_vinfo *vinfo = buf;
 	__u64 first, last;
 	void *kaddr;
 	unsigned long entries_per_block = NILFS_MDT(dat)->mi_entries_per_block;
 	int i, j, n, ret;
 	for (i = 0; i < nvi; i += n) {
 		ret = nilfs_palloc_get_entry_block(dat, vinfo->vi_vblocknr,
 						   0, &entry_bh);
 		if (ret < 0)
 			return ret;
 		kaddr = kmap_atomic(entry_bh->b_page, KM_USER0);
 		/* last virtual block number in this block */
 		first = vinfo->vi_vblocknr;
 		do_div(first, entries_per_block);
 		first *= entries_per_block;
 		last = first + entries_per_block - 1;
 		for (j = i, n = 0;
 		     j < nvi && vinfo->vi_vblocknr >= first &&
 			     vinfo->vi_vblocknr <= last;
 		     j++, n++, vinfo = (void *)vinfo + visz) {
 			entry = nilfs_palloc_block_get_entry(
 				dat, vinfo->vi_vblocknr, entry_bh, kaddr);
 			vinfo->vi_start = le64_to_cpu(entry->de_start);
 			vinfo->vi_end = le64_to_cpu(entry->de_end);
 			vinfo->vi_blocknr = le64_to_cpu(entry->de_blocknr);
 		}
 		kunmap_atomic(kaddr, KM_USER0);
 		brelse(entry_bh);
 	}
 	return nvi;
 }
 /**
+ * nilfs_dat_read - read dat inode
+ * @dat: dat inode
+ * @raw_inode: on-disk dat inode
+ */
+int nilfs_dat_read(struct inode *dat, struct nilfs_inode *raw_inode)
+{
+	return nilfs_read_inode_common(dat, raw_inode);
+}
+/**
  * nilfs_dat_new - create dat file
  * @nilfs: nilfs object
  * @entry_size: size of a dat entry
  */
 struct inode *nilfs_dat_new(struct the_nilfs *nilfs, size_t entry_size)
 {
 	static struct lock_class_key dat_lock_key;
 	struct inode *dat;
 	int err;
 	dat = nilfs_mdt_new(nilfs, NULL, NILFS_DAT_INO, 0);
 	if (dat) {
 		err = nilfs_palloc_init_blockgroup(dat, entry_size);
 		if (unlikely(err)) {
 			nilfs_mdt_destroy(dat);
 			return NULL;
 		}
 		lockdep_set_class(&NILFS_MDT(dat)->mi_sem, &dat_lock_key);
 	}
 	return dat;
 }

fs/nilfs2/dat.h

Diff comments View file @ 8707df3

 /*
  * dat.h - NILFS disk address translation.
  *
  * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  * Written by Koji Sato <koji@osrg.net>.
  */
 #ifndef _NILFS_DAT_H
 #define _NILFS_DAT_H
 #include <linux/types.h>
 #include <linux/buffer_head.h>
 #include <linux/fs.h>
 struct nilfs_palloc_req;
 int nilfs_dat_translate(struct inode *, __u64, sector_t *);
 int nilfs_dat_prepare_alloc(struct inode *, struct nilfs_palloc_req *);
 void nilfs_dat_commit_alloc(struct inode *, struct nilfs_palloc_req *);
 void nilfs_dat_abort_alloc(struct inode *, struct nilfs_palloc_req *);
 int nilfs_dat_prepare_start(struct inode *, struct nilfs_palloc_req *);
 void nilfs_dat_commit_start(struct inode *, struct nilfs_palloc_req *,
 			    sector_t);
 int nilfs_dat_prepare_end(struct inode *, struct nilfs_palloc_req *);
 void nilfs_dat_commit_end(struct inode *, struct nilfs_palloc_req *, int);
 void nilfs_dat_abort_end(struct inode *, struct nilfs_palloc_req *);
 int nilfs_dat_prepare_update(struct inode *, struct nilfs_palloc_req *,
 			     struct nilfs_palloc_req *);
 void nilfs_dat_commit_update(struct inode *, struct nilfs_palloc_req *,
 			     struct nilfs_palloc_req *, int);
 void nilfs_dat_abort_update(struct inode *, struct nilfs_palloc_req *,
 			    struct nilfs_palloc_req *);
 int nilfs_dat_mark_dirty(struct inode *, __u64);
 int nilfs_dat_freev(struct inode *, __u64 *, size_t);
 int nilfs_dat_move(struct inode *, __u64, sector_t);
 ssize_t nilfs_dat_get_vinfo(struct inode *, void *, unsigned, size_t);
+int nilfs_dat_read(struct inode *dat, struct nilfs_inode *raw_inode);
 struct inode *nilfs_dat_new(struct the_nilfs *nilfs, size_t entry_size);
 #endif	/* _NILFS_DAT_H */

fs/nilfs2/sufile.c

Diff comments View file @ 8707df3

 /*
  * sufile.c - NILFS segment usage file.
  *
  * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  * Written by Koji Sato <koji@osrg.net>.
  * Rivised by Ryusuke Konishi <ryusuke@osrg.net>.
  */
 #include <linux/kernel.h>
 #include <linux/fs.h>
 #include <linux/string.h>
 #include <linux/buffer_head.h>
 #include <linux/errno.h>
 #include <linux/nilfs2_fs.h>
 #include "mdt.h"
 #include "sufile.h"
 static inline unsigned long
 nilfs_sufile_segment_usages_per_block(const struct inode *sufile)
 {
 	return NILFS_MDT(sufile)->mi_entries_per_block;
 }
 static unsigned long
 nilfs_sufile_get_blkoff(const struct inode *sufile, __u64 segnum)
 {
 	__u64 t = segnum + NILFS_MDT(sufile)->mi_first_entry_offset;
 	do_div(t, nilfs_sufile_segment_usages_per_block(sufile));
 	return (unsigned long)t;
 }
 static unsigned long
 nilfs_sufile_get_offset(const struct inode *sufile, __u64 segnum)
 {
 	__u64 t = segnum + NILFS_MDT(sufile)->mi_first_entry_offset;
 	return do_div(t, nilfs_sufile_segment_usages_per_block(sufile));
 }
 static unsigned long
 nilfs_sufile_segment_usages_in_block(const struct inode *sufile, __u64 curr,
 				     __u64 max)
 {
 	return min_t(unsigned long,
 		     nilfs_sufile_segment_usages_per_block(sufile) -
 		     nilfs_sufile_get_offset(sufile, curr),
 		     max - curr + 1);
 }
 static inline struct nilfs_sufile_header *
 nilfs_sufile_block_get_header(const struct inode *sufile,
 			      struct buffer_head *bh,
 			      void *kaddr)
 {
 	return kaddr + bh_offset(bh);
 }
 static struct nilfs_segment_usage *
 nilfs_sufile_block_get_segment_usage(const struct inode *sufile, __u64 segnum,
 				     struct buffer_head *bh, void *kaddr)
 {
 	return kaddr + bh_offset(bh) +
 		nilfs_sufile_get_offset(sufile, segnum) *
 		NILFS_MDT(sufile)->mi_entry_size;
 }
 static inline int nilfs_sufile_get_header_block(struct inode *sufile,
 						struct buffer_head **bhp)
 {
 	return nilfs_mdt_get_block(sufile, 0, 0, NULL, bhp);
 }
 static inline int
 nilfs_sufile_get_segment_usage_block(struct inode *sufile, __u64 segnum,
 				     int create, struct buffer_head **bhp)
 {
 	return nilfs_mdt_get_block(sufile,
 				   nilfs_sufile_get_blkoff(sufile, segnum),
 				   create, NULL, bhp);
 }
 static void nilfs_sufile_mod_counter(struct buffer_head *header_bh,
 				     u64 ncleanadd, u64 ndirtyadd)
 {
 	struct nilfs_sufile_header *header;
 	void *kaddr;
 	kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
 	header = kaddr + bh_offset(header_bh);
 	le64_add_cpu(&header->sh_ncleansegs, ncleanadd);
 	le64_add_cpu(&header->sh_ndirtysegs, ndirtyadd);
 	kunmap_atomic(kaddr, KM_USER0);
 	nilfs_mdt_mark_buffer_dirty(header_bh);
 }
 /**
  * nilfs_sufile_updatev - modify multiple segment usages at a time
  * @sufile: inode of segment usage file
  * @segnumv: array of segment numbers
  * @nsegs: size of @segnumv array
  * @create: creation flag
  * @ndone: place to store number of modified segments on @segnumv
  * @dofunc: primitive operation for the update
  *
  * Description: nilfs_sufile_updatev() repeatedly calls @dofunc
  * against the given array of segments.  The @dofunc is called with
  * buffers of a header block and the sufile block in which the target
  * segment usage entry is contained.  If @ndone is given, the number
  * of successfully modified segments from the head is stored in the
  * place @ndone points to.
  *
  * Return Value: On success, zero is returned.  On error, one of the
  * following negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  *
  * %-ENOENT - Given segment usage is in hole block (may be returned if
  *            @create is zero)
  *
  * %-EINVAL - Invalid segment usage number
  */
 int nilfs_sufile_updatev(struct inode *sufile, __u64 *segnumv, size_t nsegs,
 			 int create, size_t *ndone,
 			 void (*dofunc)(struct inode *, __u64,
 					struct buffer_head *,
 					struct buffer_head *))
 {
 	struct buffer_head *header_bh, *bh;
 	unsigned long blkoff, prev_blkoff;
 	__u64 *seg;
 	size_t nerr = 0, n = 0;
 	int ret = 0;
 	if (unlikely(nsegs == 0))
 		goto out;
 	down_write(&NILFS_MDT(sufile)->mi_sem);
 	for (seg = segnumv; seg < segnumv + nsegs; seg++) {
 		if (unlikely(*seg >= nilfs_sufile_get_nsegments(sufile))) {
 			printk(KERN_WARNING
 			       "%s: invalid segment number: %llu\n", __func__,
 			       (unsigned long long)*seg);
 			nerr++;
 		}
 	}
 	if (nerr > 0) {
 		ret = -EINVAL;
 		goto out_sem;
 	}
 	ret = nilfs_sufile_get_header_block(sufile, &header_bh);
 	if (ret < 0)
 		goto out_sem;
 	seg = segnumv;
 	blkoff = nilfs_sufile_get_blkoff(sufile, *seg);
 	ret = nilfs_mdt_get_block(sufile, blkoff, create, NULL, &bh);
 	if (ret < 0)
 		goto out_header;
 	for (;;) {
 		dofunc(sufile, *seg, header_bh, bh);
 		if (++seg >= segnumv + nsegs)
 			break;
 		prev_blkoff = blkoff;
 		blkoff = nilfs_sufile_get_blkoff(sufile, *seg);
 		if (blkoff == prev_blkoff)
 			continue;
 		/* get different block */
 		brelse(bh);
 		ret = nilfs_mdt_get_block(sufile, blkoff, create, NULL, &bh);
 		if (unlikely(ret < 0))
 			goto out_header;
 	}
 	brelse(bh);
  out_header:
 	n = seg - segnumv;
 	brelse(header_bh);
  out_sem:
 	up_write(&NILFS_MDT(sufile)->mi_sem);
  out:
 	if (ndone)
 		*ndone = n;
 	return ret;
 }
 int nilfs_sufile_update(struct inode *sufile, __u64 segnum, int create,
 			void (*dofunc)(struct inode *, __u64,
 				       struct buffer_head *,
 				       struct buffer_head *))
 {
 	struct buffer_head *header_bh, *bh;
 	int ret;
 	if (unlikely(segnum >= nilfs_sufile_get_nsegments(sufile))) {
 		printk(KERN_WARNING "%s: invalid segment number: %llu\n",
 		       __func__, (unsigned long long)segnum);
 		return -EINVAL;
 	}
 	down_write(&NILFS_MDT(sufile)->mi_sem);
 	ret = nilfs_sufile_get_header_block(sufile, &header_bh);
 	if (ret < 0)
 		goto out_sem;
 	ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, create, &bh);
 	if (!ret) {
 		dofunc(sufile, segnum, header_bh, bh);
 		brelse(bh);
 	}
 	brelse(header_bh);
  out_sem:
 	up_write(&NILFS_MDT(sufile)->mi_sem);
 	return ret;
 }
 /**
  * nilfs_sufile_alloc - allocate a segment
  * @sufile: inode of segment usage file
  * @segnump: pointer to segment number
  *
  * Description: nilfs_sufile_alloc() allocates a clean segment.
  *
  * Return Value: On success, 0 is returned and the segment number of the
  * allocated segment is stored in the place pointed by @segnump. On error, one
  * of the following negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  *
  * %-ENOSPC - No clean segment left.
  */
 int nilfs_sufile_alloc(struct inode *sufile, __u64 *segnump)
 {
 	struct buffer_head *header_bh, *su_bh;
 	struct nilfs_sufile_header *header;
 	struct nilfs_segment_usage *su;
 	size_t susz = NILFS_MDT(sufile)->mi_entry_size;
 	__u64 segnum, maxsegnum, last_alloc;
 	void *kaddr;
 	unsigned long nsegments, ncleansegs, nsus;
 	int ret, i, j;
 	down_write(&NILFS_MDT(sufile)->mi_sem);
 	ret = nilfs_sufile_get_header_block(sufile, &header_bh);
 	if (ret < 0)
 		goto out_sem;
 	kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
 	header = nilfs_sufile_block_get_header(sufile, header_bh, kaddr);
 	ncleansegs = le64_to_cpu(header->sh_ncleansegs);
 	last_alloc = le64_to_cpu(header->sh_last_alloc);
 	kunmap_atomic(kaddr, KM_USER0);
 	nsegments = nilfs_sufile_get_nsegments(sufile);
 	segnum = last_alloc + 1;
 	maxsegnum = nsegments - 1;
 	for (i = 0; i < nsegments; i += nsus) {
 		if (segnum >= nsegments) {
 			/* wrap around */
 			segnum = 0;
 			maxsegnum = last_alloc;
 		}
 		ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 1,
 							   &su_bh);
 		if (ret < 0)
 			goto out_header;
 		kaddr = kmap_atomic(su_bh->b_page, KM_USER0);
 		su = nilfs_sufile_block_get_segment_usage(
 			sufile, segnum, su_bh, kaddr);
 		nsus = nilfs_sufile_segment_usages_in_block(
 			sufile, segnum, maxsegnum);
 		for (j = 0; j < nsus; j++, su = (void *)su + susz, segnum++) {
 			if (!nilfs_segment_usage_clean(su))
 				continue;
 			/* found a clean segment */
 			nilfs_segment_usage_set_dirty(su);
 			kunmap_atomic(kaddr, KM_USER0);
 			kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
 			header = nilfs_sufile_block_get_header(
 				sufile, header_bh, kaddr);
 			le64_add_cpu(&header->sh_ncleansegs, -1);
 			le64_add_cpu(&header->sh_ndirtysegs, 1);
 			header->sh_last_alloc = cpu_to_le64(segnum);
 			kunmap_atomic(kaddr, KM_USER0);
 			nilfs_mdt_mark_buffer_dirty(header_bh);
 			nilfs_mdt_mark_buffer_dirty(su_bh);
 			nilfs_mdt_mark_dirty(sufile);
 			brelse(su_bh);
 			*segnump = segnum;
 			goto out_header;
 		}
 		kunmap_atomic(kaddr, KM_USER0);
 		brelse(su_bh);
 	}
 	/* no segments left */
 	ret = -ENOSPC;
  out_header:
 	brelse(header_bh);
  out_sem:
 	up_write(&NILFS_MDT(sufile)->mi_sem);
 	return ret;
 }
 void nilfs_sufile_do_cancel_free(struct inode *sufile, __u64 segnum,
 				 struct buffer_head *header_bh,
 				 struct buffer_head *su_bh)
 {
 	struct nilfs_segment_usage *su;
 	void *kaddr;
 	kaddr = kmap_atomic(su_bh->b_page, KM_USER0);
 	su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr);
 	if (unlikely(!nilfs_segment_usage_clean(su))) {
 		printk(KERN_WARNING "%s: segment %llu must be clean\n",
 		       __func__, (unsigned long long)segnum);
 		kunmap_atomic(kaddr, KM_USER0);
 		return;
 	}
 	nilfs_segment_usage_set_dirty(su);
 	kunmap_atomic(kaddr, KM_USER0);
 	nilfs_sufile_mod_counter(header_bh, -1, 1);
 	nilfs_mdt_mark_buffer_dirty(su_bh);
 	nilfs_mdt_mark_dirty(sufile);
 }
 void nilfs_sufile_do_scrap(struct inode *sufile, __u64 segnum,
 			   struct buffer_head *header_bh,
 			   struct buffer_head *su_bh)
 {
 	struct nilfs_segment_usage *su;
 	void *kaddr;
 	int clean, dirty;
 	kaddr = kmap_atomic(su_bh->b_page, KM_USER0);
 	su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr);
 	if (su->su_flags == cpu_to_le32(1UL << NILFS_SEGMENT_USAGE_DIRTY) &&
 	    su->su_nblocks == cpu_to_le32(0)) {
 		kunmap_atomic(kaddr, KM_USER0);
 		return;
 	}
 	clean = nilfs_segment_usage_clean(su);
 	dirty = nilfs_segment_usage_dirty(su);
 	/* make the segment garbage */
 	su->su_lastmod = cpu_to_le64(0);
 	su->su_nblocks = cpu_to_le32(0);
 	su->su_flags = cpu_to_le32(1UL << NILFS_SEGMENT_USAGE_DIRTY);
 	kunmap_atomic(kaddr, KM_USER0);
 	nilfs_sufile_mod_counter(header_bh, clean ? (u64)-1 : 0, dirty ? 0 : 1);
 	nilfs_mdt_mark_buffer_dirty(su_bh);
 	nilfs_mdt_mark_dirty(sufile);
 }
 void nilfs_sufile_do_free(struct inode *sufile, __u64 segnum,
 			  struct buffer_head *header_bh,
 			  struct buffer_head *su_bh)
 {
 	struct nilfs_segment_usage *su;
 	void *kaddr;
 	int sudirty;
 	kaddr = kmap_atomic(su_bh->b_page, KM_USER0);
 	su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr);
 	if (nilfs_segment_usage_clean(su)) {
 		printk(KERN_WARNING "%s: segment %llu is already clean\n",
 		       __func__, (unsigned long long)segnum);
 		kunmap_atomic(kaddr, KM_USER0);
 		return;
 	}
 	WARN_ON(nilfs_segment_usage_error(su));
 	WARN_ON(!nilfs_segment_usage_dirty(su));
 	sudirty = nilfs_segment_usage_dirty(su);
 	nilfs_segment_usage_set_clean(su);
 	kunmap_atomic(kaddr, KM_USER0);
 	nilfs_mdt_mark_buffer_dirty(su_bh);
 	nilfs_sufile_mod_counter(header_bh, 1, sudirty ? (u64)-1 : 0);
 	nilfs_mdt_mark_dirty(sufile);
 }
 /**
  * nilfs_sufile_get_segment_usage - get a segment usage
  * @sufile: inode of segment usage file
  * @segnum: segment number
  * @sup: pointer to segment usage
  * @bhp: pointer to buffer head
  *
  * Description: nilfs_sufile_get_segment_usage() acquires the segment usage
  * specified by @segnum.
  *
  * Return Value: On success, 0 is returned, and the segment usage and the
  * buffer head of the buffer on which the segment usage is located are stored
  * in the place pointed by @sup and @bhp, respectively. On error, one of the
  * following negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  *
  * %-EINVAL - Invalid segment usage number.
  */
 int nilfs_sufile_get_segment_usage(struct inode *sufile, __u64 segnum,
 				   struct nilfs_segment_usage **sup,
 				   struct buffer_head **bhp)
 {
 	struct buffer_head *bh;
 	struct nilfs_segment_usage *su;
 	void *kaddr;
 	int ret;
 	/* segnum is 0 origin */
 	if (segnum >= nilfs_sufile_get_nsegments(sufile))
 		return -EINVAL;
 	down_write(&NILFS_MDT(sufile)->mi_sem);
 	ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 1, &bh);
 	if (ret < 0)
 		goto out_sem;
 	kaddr = kmap(bh->b_page);
 	su = nilfs_sufile_block_get_segment_usage(sufile, segnum, bh, kaddr);
 	if (nilfs_segment_usage_error(su)) {
 		kunmap(bh->b_page);
 		brelse(bh);
 		ret = -EINVAL;
 		goto out_sem;
 	}
 	if (sup != NULL)
 		*sup = su;
 	*bhp = bh;
  out_sem:
 	up_write(&NILFS_MDT(sufile)->mi_sem);
 	return ret;
 }
 /**
  * nilfs_sufile_put_segment_usage - put a segment usage
  * @sufile: inode of segment usage file
  * @segnum: segment number
  * @bh: buffer head
  *
  * Description: nilfs_sufile_put_segment_usage() releases the segment usage
  * specified by @segnum. @bh must be the buffer head which have been returned
  * by a previous call to nilfs_sufile_get_segment_usage() with @segnum.
  */
 void nilfs_sufile_put_segment_usage(struct inode *sufile, __u64 segnum,
 				    struct buffer_head *bh)
 {
 	kunmap(bh->b_page);
 	brelse(bh);
 }
 /**
  * nilfs_sufile_get_stat - get segment usage statistics
  * @sufile: inode of segment usage file
  * @stat: pointer to a structure of segment usage statistics
  *
  * Description: nilfs_sufile_get_stat() returns information about segment
  * usage.
  *
  * Return Value: On success, 0 is returned, and segment usage information is
  * stored in the place pointed by @stat. On error, one of the following
  * negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  */
 int nilfs_sufile_get_stat(struct inode *sufile, struct nilfs_sustat *sustat)
 {
 	struct buffer_head *header_bh;
 	struct nilfs_sufile_header *header;
 	struct the_nilfs *nilfs = NILFS_MDT(sufile)->mi_nilfs;
 	void *kaddr;
 	int ret;
 	down_read(&NILFS_MDT(sufile)->mi_sem);
 	ret = nilfs_sufile_get_header_block(sufile, &header_bh);
 	if (ret < 0)
 		goto out_sem;
 	kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
 	header = nilfs_sufile_block_get_header(sufile, header_bh, kaddr);
 	sustat->ss_nsegs = nilfs_sufile_get_nsegments(sufile);
 	sustat->ss_ncleansegs = le64_to_cpu(header->sh_ncleansegs);
 	sustat->ss_ndirtysegs = le64_to_cpu(header->sh_ndirtysegs);
 	sustat->ss_ctime = nilfs->ns_ctime;
 	sustat->ss_nongc_ctime = nilfs->ns_nongc_ctime;
 	spin_lock(&nilfs->ns_last_segment_lock);
 	sustat->ss_prot_seq = nilfs->ns_prot_seq;
 	spin_unlock(&nilfs->ns_last_segment_lock);
 	kunmap_atomic(kaddr, KM_USER0);
 	brelse(header_bh);
  out_sem:
 	up_read(&NILFS_MDT(sufile)->mi_sem);
 	return ret;
 }
 /**
  * nilfs_sufile_get_ncleansegs - get the number of clean segments
  * @sufile: inode of segment usage file
  * @nsegsp: pointer to the number of clean segments
  *
  * Description: nilfs_sufile_get_ncleansegs() acquires the number of clean
  * segments.
  *
  * Return Value: On success, 0 is returned and the number of clean segments is
  * stored in the place pointed by @nsegsp. On error, one of the following
  * negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  */
 int nilfs_sufile_get_ncleansegs(struct inode *sufile, unsigned long *nsegsp)
 {
 	struct nilfs_sustat sustat;
 	int ret;
 	ret = nilfs_sufile_get_stat(sufile, &sustat);
 	if (ret == 0)
 		*nsegsp = sustat.ss_ncleansegs;
 	return ret;
 }
 void nilfs_sufile_do_set_error(struct inode *sufile, __u64 segnum,
 			       struct buffer_head *header_bh,
 			       struct buffer_head *su_bh)
 {
 	struct nilfs_segment_usage *su;
 	void *kaddr;
 	int suclean;
 	kaddr = kmap_atomic(su_bh->b_page, KM_USER0);
 	su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr);
 	if (nilfs_segment_usage_error(su)) {
 		kunmap_atomic(kaddr, KM_USER0);
 		return;
 	}
 	suclean = nilfs_segment_usage_clean(su);
 	nilfs_segment_usage_set_error(su);
 	kunmap_atomic(kaddr, KM_USER0);
 	if (suclean)
 		nilfs_sufile_mod_counter(header_bh, -1, 0);
 	nilfs_mdt_mark_buffer_dirty(su_bh);
 	nilfs_mdt_mark_dirty(sufile);
 }
 /**
  * nilfs_sufile_get_suinfo -
  * @sufile: inode of segment usage file
  * @segnum: segment number to start looking
  * @buf: array of suinfo
  * @sisz: byte size of suinfo
  * @nsi: size of suinfo array
  *
  * Description:
  *
  * Return Value: On success, 0 is returned and .... On error, one of the
  * following negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  */
 ssize_t nilfs_sufile_get_suinfo(struct inode *sufile, __u64 segnum, void *buf,
 				unsigned sisz, size_t nsi)
 {
 	struct buffer_head *su_bh;
 	struct nilfs_segment_usage *su;
 	struct nilfs_suinfo *si = buf;
 	size_t susz = NILFS_MDT(sufile)->mi_entry_size;
 	struct the_nilfs *nilfs = NILFS_MDT(sufile)->mi_nilfs;
 	void *kaddr;
 	unsigned long nsegs, segusages_per_block;
 	ssize_t n;
 	int ret, i, j;
 	down_read(&NILFS_MDT(sufile)->mi_sem);
 	segusages_per_block = nilfs_sufile_segment_usages_per_block(sufile);
 	nsegs = min_t(unsigned long,
 		      nilfs_sufile_get_nsegments(sufile) - segnum,
 		      nsi);
 	for (i = 0; i < nsegs; i += n, segnum += n) {
 		n = min_t(unsigned long,
 			  segusages_per_block -
 				  nilfs_sufile_get_offset(sufile, segnum),
 			  nsegs - i);
 		ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 0,
 							   &su_bh);
 		if (ret < 0) {
 			if (ret != -ENOENT)
 				goto out;
 			/* hole */
 			memset(si, 0, sisz * n);
 			si = (void *)si + sisz * n;
 			continue;
 		}
 		kaddr = kmap_atomic(su_bh->b_page, KM_USER0);
 		su = nilfs_sufile_block_get_segment_usage(
 			sufile, segnum, su_bh, kaddr);
 		for (j = 0; j < n;
 		     j++, su = (void *)su + susz, si = (void *)si + sisz) {
 			si->sui_lastmod = le64_to_cpu(su->su_lastmod);
 			si->sui_nblocks = le32_to_cpu(su->su_nblocks);
 			si->sui_flags = le32_to_cpu(su->su_flags) &
 				~(1UL << NILFS_SEGMENT_USAGE_ACTIVE);
 			if (nilfs_segment_is_active(nilfs, segnum + j))
 				si->sui_flags |=
 					(1UL << NILFS_SEGMENT_USAGE_ACTIVE);
 		}
 		kunmap_atomic(kaddr, KM_USER0);
 		brelse(su_bh);
 	}
 	ret = nsegs;
  out:
 	up_read(&NILFS_MDT(sufile)->mi_sem);
 	return ret;
 }
 /**
+ * nilfs_sufile_read - read sufile inode
+ * @sufile: sufile inode
+ * @raw_inode: on-disk sufile inode
+ */
+int nilfs_sufile_read(struct inode *sufile, struct nilfs_inode *raw_inode)
+{
+	return nilfs_read_inode_common(sufile, raw_inode);
+}
+/**
  * nilfs_sufile_new - create sufile
  * @nilfs: nilfs object
  * @susize: size of a segment usage entry
  */
 struct inode *nilfs_sufile_new(struct the_nilfs *nilfs, size_t susize)
 {
 	struct inode *sufile;
 	sufile = nilfs_mdt_new(nilfs, NULL, NILFS_SUFILE_INO, 0);
 	if (sufile)
 		nilfs_mdt_set_entry_size(sufile, susize,
 					 sizeof(struct nilfs_sufile_header));
 	return sufile;
 }

fs/nilfs2/sufile.h

Diff comments View file @ 8707df3

 /*
  * sufile.h - NILFS segment usage file.
  *
  * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  * Written by Koji Sato <koji@osrg.net>.
  */
 #ifndef _NILFS_SUFILE_H
 #define _NILFS_SUFILE_H
 #include <linux/fs.h>
 #include <linux/buffer_head.h>
 #include <linux/nilfs2_fs.h>
 #include "mdt.h"
 static inline unsigned long nilfs_sufile_get_nsegments(struct inode *sufile)
 {
 	return NILFS_MDT(sufile)->mi_nilfs->ns_nsegments;
 }
 int nilfs_sufile_alloc(struct inode *, __u64 *);
 int nilfs_sufile_get_segment_usage(struct inode *, __u64,
 				   struct nilfs_segment_usage **,
 				   struct buffer_head **);
 void nilfs_sufile_put_segment_usage(struct inode *, __u64,
 				    struct buffer_head *);
 int nilfs_sufile_get_stat(struct inode *, struct nilfs_sustat *);
 int nilfs_sufile_get_ncleansegs(struct inode *, unsigned long *);
 ssize_t nilfs_sufile_get_suinfo(struct inode *, __u64, void *, unsigned,
 				size_t);
 int nilfs_sufile_updatev(struct inode *, __u64 *, size_t, int, size_t *,
 			 void (*dofunc)(struct inode *, __u64,
 					struct buffer_head *,
 					struct buffer_head *));
 int nilfs_sufile_update(struct inode *, __u64, int,
 			void (*dofunc)(struct inode *, __u64,
 				       struct buffer_head *,
 				       struct buffer_head *));
 void nilfs_sufile_do_scrap(struct inode *, __u64, struct buffer_head *,
 			   struct buffer_head *);
 void nilfs_sufile_do_free(struct inode *, __u64, struct buffer_head *,
 			  struct buffer_head *);
 void nilfs_sufile_do_cancel_free(struct inode *, __u64, struct buffer_head *,
 				 struct buffer_head *);
 void nilfs_sufile_do_set_error(struct inode *, __u64, struct buffer_head *,
 			       struct buffer_head *);
+int nilfs_sufile_read(struct inode *sufile, struct nilfs_inode *raw_inode);
 struct inode *nilfs_sufile_new(struct the_nilfs *nilfs, size_t susize);
 /**
  * nilfs_sufile_scrap - make a segment garbage
  * @sufile: inode of segment usage file
  * @segnum: segment number to be freed
  */
 static inline int nilfs_sufile_scrap(struct inode *sufile, __u64 segnum)
 {
 	return nilfs_sufile_update(sufile, segnum, 1, nilfs_sufile_do_scrap);
 }
 /**
  * nilfs_sufile_free - free segment
  * @sufile: inode of segment usage file
  * @segnum: segment number to be freed
  */
 static inline int nilfs_sufile_free(struct inode *sufile, __u64 segnum)
 {
 	return nilfs_sufile_update(sufile, segnum, 0, nilfs_sufile_do_free);
 }
 /**
  * nilfs_sufile_freev - free segments
  * @sufile: inode of segment usage file
  * @segnumv: array of segment numbers
  * @nsegs: size of @segnumv array
  * @ndone: place to store the number of freed segments
  */
 static inline int nilfs_sufile_freev(struct inode *sufile, __u64 *segnumv,
 				     size_t nsegs, size_t *ndone)
 {
 	return nilfs_sufile_updatev(sufile, segnumv, nsegs, 0, ndone,
 				    nilfs_sufile_do_free);
 }
 /**
  * nilfs_sufile_cancel_freev - reallocate freeing segments
  * @sufile: inode of segment usage file
  * @segnumv: array of segment numbers
  * @nsegs: size of @segnumv array
  * @ndone: place to store the number of cancelled segments
  *
  * Return Value: On success, 0 is returned. On error, a negative error codes
  * is returned.
  */
 static inline int nilfs_sufile_cancel_freev(struct inode *sufile,
 					    __u64 *segnumv, size_t nsegs,
 					    size_t *ndone)
 {
 	return nilfs_sufile_updatev(sufile, segnumv, nsegs, 0, ndone,
 				    nilfs_sufile_do_cancel_free);
 }
 /**
  * nilfs_sufile_set_error - mark a segment as erroneous
  * @sufile: inode of segment usage file
  * @segnum: segment number
  *
  * Description: nilfs_sufile_set_error() marks the segment specified by
  * @segnum as erroneous. The error segment will never be used again.
  *
  * Return Value: On success, 0 is returned. On error, one of the following
  * negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  *
  * %-EINVAL - Invalid segment usage number.
  */
 static inline int nilfs_sufile_set_error(struct inode *sufile, __u64 segnum)
 {
 	return nilfs_sufile_update(sufile, segnum, 0,
 				   nilfs_sufile_do_set_error);
 }
 #endif	/* _NILFS_SUFILE_H */

fs/nilfs2/the_nilfs.c

Diff comments View file @ 8707df3

1	/*	1	/*
2	* the_nilfs.c - the_nilfs shared structure.	2	* the_nilfs.c - the_nilfs shared structure.
3	*	3	*
4	* Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.	4	* Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
5	*	5	*
6	* This program is free software; you can redistribute it and/or modify	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	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	8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.	9	* (at your option) any later version.
10	*	10	*
11	* This program is distributed in the hope that it will be useful,	11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.	14	* GNU General Public License for more details.
15	*	15	*
16	* You should have received a copy of the GNU General Public License	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	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	18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19	*	19	*
20	* Written by Ryusuke Konishi <ryusuke@osrg.net>	20	* Written by Ryusuke Konishi <ryusuke@osrg.net>
21	*	21	*
22	*/	22	*/
23		23
24	#include <linux/buffer_head.h>	24	#include <linux/buffer_head.h>
25	#include <linux/slab.h>	25	#include <linux/slab.h>
26	#include <linux/blkdev.h>	26	#include <linux/blkdev.h>
27	#include <linux/backing-dev.h>	27	#include <linux/backing-dev.h>
28	#include <linux/crc32.h>	28	#include <linux/crc32.h>
29	#include "nilfs.h"	29	#include "nilfs.h"
30	#include "segment.h"	30	#include "segment.h"
31	#include "alloc.h"	31	#include "alloc.h"
32	#include "cpfile.h"	32	#include "cpfile.h"
33	#include "sufile.h"	33	#include "sufile.h"
34	#include "dat.h"	34	#include "dat.h"
35	#include "segbuf.h"	35	#include "segbuf.h"
36		36
37		37
38	static LIST_HEAD(nilfs_objects);	38	static LIST_HEAD(nilfs_objects);
39	static DEFINE_SPINLOCK(nilfs_lock);	39	static DEFINE_SPINLOCK(nilfs_lock);
40		40
41	void nilfs_set_last_segment(struct the_nilfs *nilfs,	41	void nilfs_set_last_segment(struct the_nilfs *nilfs,
42	sector_t start_blocknr, u64 seq, __u64 cno)	42	sector_t start_blocknr, u64 seq, __u64 cno)
43	{	43	{
44	spin_lock(&nilfs->ns_last_segment_lock);	44	spin_lock(&nilfs->ns_last_segment_lock);
45	nilfs->ns_last_pseg = start_blocknr;	45	nilfs->ns_last_pseg = start_blocknr;
46	nilfs->ns_last_seq = seq;	46	nilfs->ns_last_seq = seq;
47	nilfs->ns_last_cno = cno;	47	nilfs->ns_last_cno = cno;
48	spin_unlock(&nilfs->ns_last_segment_lock);	48	spin_unlock(&nilfs->ns_last_segment_lock);
49	}	49	}
50		50
51	/**	51	/**
52	* alloc_nilfs - allocate the_nilfs structure	52	* alloc_nilfs - allocate the_nilfs structure
53	* @bdev: block device to which the_nilfs is related	53	* @bdev: block device to which the_nilfs is related
54	*	54	*
55	* alloc_nilfs() allocates memory for the_nilfs and	55	* alloc_nilfs() allocates memory for the_nilfs and
56	* initializes its reference count and locks.	56	* initializes its reference count and locks.
57	*	57	*
58	* Return Value: On success, pointer to the_nilfs is returned.	58	* Return Value: On success, pointer to the_nilfs is returned.
59	* On error, NULL is returned.	59	* On error, NULL is returned.
60	*/	60	*/
61	static struct the_nilfs alloc_nilfs(struct block_device bdev)	61	static struct the_nilfs alloc_nilfs(struct block_device bdev)
62	{	62	{
63	struct the_nilfs *nilfs;	63	struct the_nilfs *nilfs;
64		64
65	nilfs = kzalloc(sizeof(*nilfs), GFP_KERNEL);	65	nilfs = kzalloc(sizeof(*nilfs), GFP_KERNEL);
66	if (!nilfs)	66	if (!nilfs)
67	return NULL;	67	return NULL;
68		68
69	nilfs->ns_bdev = bdev;	69	nilfs->ns_bdev = bdev;
70	atomic_set(&nilfs->ns_count, 1);	70	atomic_set(&nilfs->ns_count, 1);
71	atomic_set(&nilfs->ns_ndirtyblks, 0);	71	atomic_set(&nilfs->ns_ndirtyblks, 0);
72	init_rwsem(&nilfs->ns_sem);	72	init_rwsem(&nilfs->ns_sem);
73	init_rwsem(&nilfs->ns_super_sem);	73	init_rwsem(&nilfs->ns_super_sem);
74	mutex_init(&nilfs->ns_mount_mutex);	74	mutex_init(&nilfs->ns_mount_mutex);
75	init_rwsem(&nilfs->ns_writer_sem);	75	init_rwsem(&nilfs->ns_writer_sem);
76	INIT_LIST_HEAD(&nilfs->ns_list);	76	INIT_LIST_HEAD(&nilfs->ns_list);
77	INIT_LIST_HEAD(&nilfs->ns_supers);	77	INIT_LIST_HEAD(&nilfs->ns_supers);
78	spin_lock_init(&nilfs->ns_last_segment_lock);	78	spin_lock_init(&nilfs->ns_last_segment_lock);
79	nilfs->ns_gc_inodes_h = NULL;	79	nilfs->ns_gc_inodes_h = NULL;
80	init_rwsem(&nilfs->ns_segctor_sem);	80	init_rwsem(&nilfs->ns_segctor_sem);
81		81
82	return nilfs;	82	return nilfs;
83	}	83	}
84		84
85	/**	85	/**
86	* find_or_create_nilfs - find or create nilfs object	86	* find_or_create_nilfs - find or create nilfs object
87	* @bdev: block device to which the_nilfs is related	87	* @bdev: block device to which the_nilfs is related
88	*	88	*
89	* find_nilfs() looks up an existent nilfs object created on the	89	* find_nilfs() looks up an existent nilfs object created on the
90	* device and gets the reference count of the object. If no nilfs object	90	* device and gets the reference count of the object. If no nilfs object
91	* is found on the device, a new nilfs object is allocated.	91	* is found on the device, a new nilfs object is allocated.
92	*	92	*
93	* Return Value: On success, pointer to the nilfs object is returned.	93	* Return Value: On success, pointer to the nilfs object is returned.
94	* On error, NULL is returned.	94	* On error, NULL is returned.
95	*/	95	*/
96	struct the_nilfs find_or_create_nilfs(struct block_device bdev)	96	struct the_nilfs find_or_create_nilfs(struct block_device bdev)
97	{	97	{
98	struct the_nilfs nilfs, new = NULL;	98	struct the_nilfs nilfs, new = NULL;
99		99
100	retry:	100	retry:
101	spin_lock(&nilfs_lock);	101	spin_lock(&nilfs_lock);
102	list_for_each_entry(nilfs, &nilfs_objects, ns_list) {	102	list_for_each_entry(nilfs, &nilfs_objects, ns_list) {
103	if (nilfs->ns_bdev == bdev) {	103	if (nilfs->ns_bdev == bdev) {
104	get_nilfs(nilfs);	104	get_nilfs(nilfs);
105	spin_unlock(&nilfs_lock);	105	spin_unlock(&nilfs_lock);
106	if (new)	106	if (new)
107	put_nilfs(new);	107	put_nilfs(new);
108	return nilfs; /* existing object */	108	return nilfs; /* existing object */
109	}	109	}
110	}	110	}
111	if (new) {	111	if (new) {
112	list_add_tail(&new->ns_list, &nilfs_objects);	112	list_add_tail(&new->ns_list, &nilfs_objects);
113	spin_unlock(&nilfs_lock);	113	spin_unlock(&nilfs_lock);
114	return new; /* new object */	114	return new; /* new object */
115	}	115	}
116	spin_unlock(&nilfs_lock);	116	spin_unlock(&nilfs_lock);
117		117
118	new = alloc_nilfs(bdev);	118	new = alloc_nilfs(bdev);
119	if (new)	119	if (new)
120	goto retry;	120	goto retry;
121	return NULL; /* insufficient memory */	121	return NULL; /* insufficient memory */
122	}	122	}
123		123
124	/**	124	/**
125	* put_nilfs - release a reference to the_nilfs	125	* put_nilfs - release a reference to the_nilfs
126	* @nilfs: the_nilfs structure to be released	126	* @nilfs: the_nilfs structure to be released
127	*	127	*
128	* put_nilfs() decrements a reference counter of the_nilfs.	128	* put_nilfs() decrements a reference counter of the_nilfs.
129	* If the reference count reaches zero, the_nilfs is freed.	129	* If the reference count reaches zero, the_nilfs is freed.
130	*/	130	*/
131	void put_nilfs(struct the_nilfs *nilfs)	131	void put_nilfs(struct the_nilfs *nilfs)
132	{	132	{
133	spin_lock(&nilfs_lock);	133	spin_lock(&nilfs_lock);
134	if (!atomic_dec_and_test(&nilfs->ns_count)) {	134	if (!atomic_dec_and_test(&nilfs->ns_count)) {
135	spin_unlock(&nilfs_lock);	135	spin_unlock(&nilfs_lock);
136	return;	136	return;
137	}	137	}
138	list_del_init(&nilfs->ns_list);	138	list_del_init(&nilfs->ns_list);
139	spin_unlock(&nilfs_lock);	139	spin_unlock(&nilfs_lock);
140		140
141	/*	141	/*
142	* Increment of ns_count never occurs below because the caller	142	* Increment of ns_count never occurs below because the caller
143	* of get_nilfs() holds at least one reference to the_nilfs.	143	* of get_nilfs() holds at least one reference to the_nilfs.
144	* Thus its exclusion control is not required here.	144	* Thus its exclusion control is not required here.
145	*/	145	*/
146		146
147	might_sleep();	147	might_sleep();
148	if (nilfs_loaded(nilfs)) {	148	if (nilfs_loaded(nilfs)) {
149	nilfs_mdt_clear(nilfs->ns_sufile);	149	nilfs_mdt_clear(nilfs->ns_sufile);
150	nilfs_mdt_destroy(nilfs->ns_sufile);	150	nilfs_mdt_destroy(nilfs->ns_sufile);
151	nilfs_mdt_clear(nilfs->ns_cpfile);	151	nilfs_mdt_clear(nilfs->ns_cpfile);
152	nilfs_mdt_destroy(nilfs->ns_cpfile);	152	nilfs_mdt_destroy(nilfs->ns_cpfile);
153	nilfs_mdt_clear(nilfs->ns_dat);	153	nilfs_mdt_clear(nilfs->ns_dat);
154	nilfs_mdt_destroy(nilfs->ns_dat);	154	nilfs_mdt_destroy(nilfs->ns_dat);
155	/* XXX: how and when to clear nilfs->ns_gc_dat? */	155	/* XXX: how and when to clear nilfs->ns_gc_dat? */
156	nilfs_mdt_destroy(nilfs->ns_gc_dat);	156	nilfs_mdt_destroy(nilfs->ns_gc_dat);
157	}	157	}
158	if (nilfs_init(nilfs)) {	158	if (nilfs_init(nilfs)) {
159	nilfs_destroy_gccache(nilfs);	159	nilfs_destroy_gccache(nilfs);
160	brelse(nilfs->ns_sbh[0]);	160	brelse(nilfs->ns_sbh[0]);
161	brelse(nilfs->ns_sbh[1]);	161	brelse(nilfs->ns_sbh[1]);
162	}	162	}
163	kfree(nilfs);	163	kfree(nilfs);
164	}	164	}
165		165
166	static int nilfs_load_super_root(struct the_nilfs *nilfs,	166	static int nilfs_load_super_root(struct the_nilfs *nilfs,
167	struct nilfs_sb_info *sbi, sector_t sr_block)	167	struct nilfs_sb_info *sbi, sector_t sr_block)
168	{	168	{
169	struct buffer_head *bh_sr;	169	struct buffer_head *bh_sr;
170	struct nilfs_super_root *raw_sr;	170	struct nilfs_super_root *raw_sr;
171	struct nilfs_super_block **sbp = nilfs->ns_sbp;	171	struct nilfs_super_block **sbp = nilfs->ns_sbp;
172	unsigned dat_entry_size, segment_usage_size, checkpoint_size;	172	unsigned dat_entry_size, segment_usage_size, checkpoint_size;
173	unsigned inode_size;	173	unsigned inode_size;
174	int err;	174	int err;
175		175
176	err = nilfs_read_super_root_block(sbi->s_super, sr_block, &bh_sr, 1);	176	err = nilfs_read_super_root_block(sbi->s_super, sr_block, &bh_sr, 1);
177	if (unlikely(err))	177	if (unlikely(err))
178	return err;	178	return err;
179		179
180	down_read(&nilfs->ns_sem);	180	down_read(&nilfs->ns_sem);
181	dat_entry_size = le16_to_cpu(sbp[0]->s_dat_entry_size);	181	dat_entry_size = le16_to_cpu(sbp[0]->s_dat_entry_size);
182	checkpoint_size = le16_to_cpu(sbp[0]->s_checkpoint_size);	182	checkpoint_size = le16_to_cpu(sbp[0]->s_checkpoint_size);
183	segment_usage_size = le16_to_cpu(sbp[0]->s_segment_usage_size);	183	segment_usage_size = le16_to_cpu(sbp[0]->s_segment_usage_size);
184	up_read(&nilfs->ns_sem);	184	up_read(&nilfs->ns_sem);
185		185
186	inode_size = nilfs->ns_inode_size;	186	inode_size = nilfs->ns_inode_size;
187		187
188	err = -ENOMEM;	188	err = -ENOMEM;
189	nilfs->ns_dat = nilfs_dat_new(nilfs, dat_entry_size);	189	nilfs->ns_dat = nilfs_dat_new(nilfs, dat_entry_size);
190	if (unlikely(!nilfs->ns_dat))	190	if (unlikely(!nilfs->ns_dat))
191	goto failed;	191	goto failed;
192		192
193	nilfs->ns_gc_dat = nilfs_dat_new(nilfs, dat_entry_size);	193	nilfs->ns_gc_dat = nilfs_dat_new(nilfs, dat_entry_size);
194	if (unlikely(!nilfs->ns_gc_dat))	194	if (unlikely(!nilfs->ns_gc_dat))
195	goto failed_dat;	195	goto failed_dat;
196		196
197	nilfs->ns_cpfile = nilfs_cpfile_new(nilfs, checkpoint_size);	197	nilfs->ns_cpfile = nilfs_cpfile_new(nilfs, checkpoint_size);
198	if (unlikely(!nilfs->ns_cpfile))	198	if (unlikely(!nilfs->ns_cpfile))
199	goto failed_gc_dat;	199	goto failed_gc_dat;
200		200
201	nilfs->ns_sufile = nilfs_sufile_new(nilfs, segment_usage_size);	201	nilfs->ns_sufile = nilfs_sufile_new(nilfs, segment_usage_size);
202	if (unlikely(!nilfs->ns_sufile))	202	if (unlikely(!nilfs->ns_sufile))
203	goto failed_cpfile;	203	goto failed_cpfile;
204		204
205	nilfs_mdt_set_shadow(nilfs->ns_dat, nilfs->ns_gc_dat);	205	nilfs_mdt_set_shadow(nilfs->ns_dat, nilfs->ns_gc_dat);
206		206
207	err = nilfs_mdt_read_inode_direct(	207	err = nilfs_dat_read(nilfs->ns_dat, (void *)bh_sr->b_data +
208	nilfs->ns_dat, bh_sr, NILFS_SR_DAT_OFFSET(inode_size));	208	NILFS_SR_DAT_OFFSET(inode_size));
209	if (unlikely(err))	209	if (unlikely(err))
210	goto failed_sufile;	210	goto failed_sufile;
211		211
212	err = nilfs_mdt_read_inode_direct(	212	err = nilfs_cpfile_read(nilfs->ns_cpfile, (void *)bh_sr->b_data +
213	nilfs->ns_cpfile, bh_sr, NILFS_SR_CPFILE_OFFSET(inode_size));	213	NILFS_SR_CPFILE_OFFSET(inode_size));
214	if (unlikely(err))	214	if (unlikely(err))
215	goto failed_sufile;	215	goto failed_sufile;
216		216
217	err = nilfs_mdt_read_inode_direct(	217	err = nilfs_sufile_read(nilfs->ns_sufile, (void *)bh_sr->b_data +
218	nilfs->ns_sufile, bh_sr, NILFS_SR_SUFILE_OFFSET(inode_size));	218	NILFS_SR_SUFILE_OFFSET(inode_size));
219	if (unlikely(err))	219	if (unlikely(err))
220	goto failed_sufile;	220	goto failed_sufile;
221		221
222	raw_sr = (struct nilfs_super_root *)bh_sr->b_data;	222	raw_sr = (struct nilfs_super_root *)bh_sr->b_data;
223	nilfs->ns_nongc_ctime = le64_to_cpu(raw_sr->sr_nongc_ctime);	223	nilfs->ns_nongc_ctime = le64_to_cpu(raw_sr->sr_nongc_ctime);
224		224
225	failed:	225	failed:
226	brelse(bh_sr);	226	brelse(bh_sr);
227	return err;	227	return err;
228		228
229	failed_sufile:	229	failed_sufile:
230	nilfs_mdt_destroy(nilfs->ns_sufile);	230	nilfs_mdt_destroy(nilfs->ns_sufile);
231		231
232	failed_cpfile:	232	failed_cpfile:
233	nilfs_mdt_destroy(nilfs->ns_cpfile);	233	nilfs_mdt_destroy(nilfs->ns_cpfile);
234		234
235	failed_gc_dat:	235	failed_gc_dat:
236	nilfs_mdt_destroy(nilfs->ns_gc_dat);	236	nilfs_mdt_destroy(nilfs->ns_gc_dat);
237		237
238	failed_dat:	238	failed_dat:
239	nilfs_mdt_destroy(nilfs->ns_dat);	239	nilfs_mdt_destroy(nilfs->ns_dat);
240	goto failed;	240	goto failed;
241	}	241	}
242		242
243	static void nilfs_init_recovery_info(struct nilfs_recovery_info *ri)	243	static void nilfs_init_recovery_info(struct nilfs_recovery_info *ri)
244	{	244	{
245	memset(ri, 0, sizeof(*ri));	245	memset(ri, 0, sizeof(*ri));
246	INIT_LIST_HEAD(&ri->ri_used_segments);	246	INIT_LIST_HEAD(&ri->ri_used_segments);
247	}	247	}
248		248
249	static void nilfs_clear_recovery_info(struct nilfs_recovery_info *ri)	249	static void nilfs_clear_recovery_info(struct nilfs_recovery_info *ri)
250	{	250	{
251	nilfs_dispose_segment_list(&ri->ri_used_segments);	251	nilfs_dispose_segment_list(&ri->ri_used_segments);
252	}	252	}
253		253
254	/**	254	/**
255	* load_nilfs - load and recover the nilfs	255	* load_nilfs - load and recover the nilfs
256	* @nilfs: the_nilfs structure to be released	256	* @nilfs: the_nilfs structure to be released
257	* @sbi: nilfs_sb_info used to recover past segment	257	* @sbi: nilfs_sb_info used to recover past segment
258	*	258	*
259	* load_nilfs() searches and load the latest super root,	259	* load_nilfs() searches and load the latest super root,
260	* attaches the last segment, and does recovery if needed.	260	* attaches the last segment, and does recovery if needed.
261	* The caller must call this exclusively for simultaneous mounts.	261	* The caller must call this exclusively for simultaneous mounts.
262	*/	262	*/
263	int load_nilfs(struct the_nilfs nilfs, struct nilfs_sb_info sbi)	263	int load_nilfs(struct the_nilfs nilfs, struct nilfs_sb_info sbi)
264	{	264	{
265	struct nilfs_recovery_info ri;	265	struct nilfs_recovery_info ri;
266	unsigned int s_flags = sbi->s_super->s_flags;	266	unsigned int s_flags = sbi->s_super->s_flags;
267	int really_read_only = bdev_read_only(nilfs->ns_bdev);	267	int really_read_only = bdev_read_only(nilfs->ns_bdev);
268	unsigned valid_fs;	268	unsigned valid_fs;
269	int err = 0;	269	int err = 0;
270		270
271	nilfs_init_recovery_info(&ri);	271	nilfs_init_recovery_info(&ri);
272		272
273	down_write(&nilfs->ns_sem);	273	down_write(&nilfs->ns_sem);
274	valid_fs = (nilfs->ns_mount_state & NILFS_VALID_FS);	274	valid_fs = (nilfs->ns_mount_state & NILFS_VALID_FS);
275	up_write(&nilfs->ns_sem);	275	up_write(&nilfs->ns_sem);
276		276
277	if (!valid_fs && (s_flags & MS_RDONLY)) {	277	if (!valid_fs && (s_flags & MS_RDONLY)) {
278	printk(KERN_INFO "NILFS: INFO: recovery "	278	printk(KERN_INFO "NILFS: INFO: recovery "
279	"required for readonly filesystem.\n");	279	"required for readonly filesystem.\n");
280	if (really_read_only) {	280	if (really_read_only) {
281	printk(KERN_ERR "NILFS: write access "	281	printk(KERN_ERR "NILFS: write access "
282	"unavailable, cannot proceed.\n");	282	"unavailable, cannot proceed.\n");
283	err = -EROFS;	283	err = -EROFS;
284	goto failed;	284	goto failed;
285	}	285	}
286	printk(KERN_INFO "NILFS: write access will "	286	printk(KERN_INFO "NILFS: write access will "
287	"be enabled during recovery.\n");	287	"be enabled during recovery.\n");
288	sbi->s_super->s_flags &= ~MS_RDONLY;	288	sbi->s_super->s_flags &= ~MS_RDONLY;
289	}	289	}
290		290
291	err = nilfs_search_super_root(nilfs, sbi, &ri);	291	err = nilfs_search_super_root(nilfs, sbi, &ri);
292	if (unlikely(err)) {	292	if (unlikely(err)) {
293	printk(KERN_ERR "NILFS: error searching super root.\n");	293	printk(KERN_ERR "NILFS: error searching super root.\n");
294	goto failed;	294	goto failed;
295	}	295	}
296		296
297	err = nilfs_load_super_root(nilfs, sbi, ri.ri_super_root);	297	err = nilfs_load_super_root(nilfs, sbi, ri.ri_super_root);
298	if (unlikely(err)) {	298	if (unlikely(err)) {
299	printk(KERN_ERR "NILFS: error loading super root.\n");	299	printk(KERN_ERR "NILFS: error loading super root.\n");
300	goto failed;	300	goto failed;
301	}	301	}
302		302
303	if (!valid_fs) {	303	if (!valid_fs) {
304	err = nilfs_recover_logical_segments(nilfs, sbi, &ri);	304	err = nilfs_recover_logical_segments(nilfs, sbi, &ri);
305	if (unlikely(err)) {	305	if (unlikely(err)) {
306	nilfs_mdt_destroy(nilfs->ns_cpfile);	306	nilfs_mdt_destroy(nilfs->ns_cpfile);
307	nilfs_mdt_destroy(nilfs->ns_sufile);	307	nilfs_mdt_destroy(nilfs->ns_sufile);
308	nilfs_mdt_destroy(nilfs->ns_dat);	308	nilfs_mdt_destroy(nilfs->ns_dat);
309	goto failed;	309	goto failed;
310	}	310	}
311	if (ri.ri_need_recovery == NILFS_RECOVERY_SR_UPDATED)	311	if (ri.ri_need_recovery == NILFS_RECOVERY_SR_UPDATED)
312	sbi->s_super->s_dirt = 1;	312	sbi->s_super->s_dirt = 1;
313	}	313	}
314		314
315	set_nilfs_loaded(nilfs);	315	set_nilfs_loaded(nilfs);
316		316
317	failed:	317	failed:
318	nilfs_clear_recovery_info(&ri);	318	nilfs_clear_recovery_info(&ri);
319	sbi->s_super->s_flags = s_flags;	319	sbi->s_super->s_flags = s_flags;
320	return err;	320	return err;
321	}	321	}
322		322
323	static unsigned long long nilfs_max_size(unsigned int blkbits)	323	static unsigned long long nilfs_max_size(unsigned int blkbits)
324	{	324	{
325	unsigned int max_bits;	325	unsigned int max_bits;
326	unsigned long long res = MAX_LFS_FILESIZE; /* page cache limit */	326	unsigned long long res = MAX_LFS_FILESIZE; /* page cache limit */
327		327
328	max_bits = blkbits + NILFS_BMAP_KEY_BIT; /* bmap size limit */	328	max_bits = blkbits + NILFS_BMAP_KEY_BIT; /* bmap size limit */
329	if (max_bits < 64)	329	if (max_bits < 64)
330	res = min_t(unsigned long long, res, (1ULL << max_bits) - 1);	330	res = min_t(unsigned long long, res, (1ULL << max_bits) - 1);
331	return res;	331	return res;
332	}	332	}
333		333
334	static int nilfs_store_disk_layout(struct the_nilfs *nilfs,	334	static int nilfs_store_disk_layout(struct the_nilfs *nilfs,
335	struct nilfs_super_block *sbp)	335	struct nilfs_super_block *sbp)
336	{	336	{
337	if (le32_to_cpu(sbp->s_rev_level) != NILFS_CURRENT_REV) {	337	if (le32_to_cpu(sbp->s_rev_level) != NILFS_CURRENT_REV) {
338	printk(KERN_ERR "NILFS: revision mismatch "	338	printk(KERN_ERR "NILFS: revision mismatch "
339	"(superblock rev.=%d.%d, current rev.=%d.%d). "	339	"(superblock rev.=%d.%d, current rev.=%d.%d). "
340	"Please check the version of mkfs.nilfs.\n",	340	"Please check the version of mkfs.nilfs.\n",
341	le32_to_cpu(sbp->s_rev_level),	341	le32_to_cpu(sbp->s_rev_level),
342	le16_to_cpu(sbp->s_minor_rev_level),	342	le16_to_cpu(sbp->s_minor_rev_level),
343	NILFS_CURRENT_REV, NILFS_MINOR_REV);	343	NILFS_CURRENT_REV, NILFS_MINOR_REV);
344	return -EINVAL;	344	return -EINVAL;
345	}	345	}
346	nilfs->ns_sbsize = le16_to_cpu(sbp->s_bytes);	346	nilfs->ns_sbsize = le16_to_cpu(sbp->s_bytes);
347	if (nilfs->ns_sbsize > BLOCK_SIZE)	347	if (nilfs->ns_sbsize > BLOCK_SIZE)
348	return -EINVAL;	348	return -EINVAL;
349		349
350	nilfs->ns_inode_size = le16_to_cpu(sbp->s_inode_size);	350	nilfs->ns_inode_size = le16_to_cpu(sbp->s_inode_size);
351	nilfs->ns_first_ino = le32_to_cpu(sbp->s_first_ino);	351	nilfs->ns_first_ino = le32_to_cpu(sbp->s_first_ino);
352		352
353	nilfs->ns_blocks_per_segment = le32_to_cpu(sbp->s_blocks_per_segment);	353	nilfs->ns_blocks_per_segment = le32_to_cpu(sbp->s_blocks_per_segment);
354	if (nilfs->ns_blocks_per_segment < NILFS_SEG_MIN_BLOCKS) {	354	if (nilfs->ns_blocks_per_segment < NILFS_SEG_MIN_BLOCKS) {
355	printk(KERN_ERR "NILFS: too short segment. \n");	355	printk(KERN_ERR "NILFS: too short segment. \n");
356	return -EINVAL;	356	return -EINVAL;
357	}	357	}
358		358
359	nilfs->ns_first_data_block = le64_to_cpu(sbp->s_first_data_block);	359	nilfs->ns_first_data_block = le64_to_cpu(sbp->s_first_data_block);
360	nilfs->ns_nsegments = le64_to_cpu(sbp->s_nsegments);	360	nilfs->ns_nsegments = le64_to_cpu(sbp->s_nsegments);
361	nilfs->ns_r_segments_percentage =	361	nilfs->ns_r_segments_percentage =
362	le32_to_cpu(sbp->s_r_segments_percentage);	362	le32_to_cpu(sbp->s_r_segments_percentage);
363	nilfs->ns_nrsvsegs =	363	nilfs->ns_nrsvsegs =
364	max_t(unsigned long, NILFS_MIN_NRSVSEGS,	364	max_t(unsigned long, NILFS_MIN_NRSVSEGS,
365	DIV_ROUND_UP(nilfs->ns_nsegments *	365	DIV_ROUND_UP(nilfs->ns_nsegments *
366	nilfs->ns_r_segments_percentage, 100));	366	nilfs->ns_r_segments_percentage, 100));
367	nilfs->ns_crc_seed = le32_to_cpu(sbp->s_crc_seed);	367	nilfs->ns_crc_seed = le32_to_cpu(sbp->s_crc_seed);
368	return 0;	368	return 0;
369	}	369	}
370		370
371	static int nilfs_valid_sb(struct nilfs_super_block *sbp)	371	static int nilfs_valid_sb(struct nilfs_super_block *sbp)
372	{	372	{
373	static unsigned char sum[4];	373	static unsigned char sum[4];
374	const int sumoff = offsetof(struct nilfs_super_block, s_sum);	374	const int sumoff = offsetof(struct nilfs_super_block, s_sum);
375	size_t bytes;	375	size_t bytes;
376	u32 crc;	376	u32 crc;
377		377
378	if (!sbp \|\| le16_to_cpu(sbp->s_magic) != NILFS_SUPER_MAGIC)	378	if (!sbp \|\| le16_to_cpu(sbp->s_magic) != NILFS_SUPER_MAGIC)
379	return 0;	379	return 0;
380	bytes = le16_to_cpu(sbp->s_bytes);	380	bytes = le16_to_cpu(sbp->s_bytes);
381	if (bytes > BLOCK_SIZE)	381	if (bytes > BLOCK_SIZE)
382	return 0;	382	return 0;
383	crc = crc32_le(le32_to_cpu(sbp->s_crc_seed), (unsigned char *)sbp,	383	crc = crc32_le(le32_to_cpu(sbp->s_crc_seed), (unsigned char *)sbp,
384	sumoff);	384	sumoff);
385	crc = crc32_le(crc, sum, 4);	385	crc = crc32_le(crc, sum, 4);
386	crc = crc32_le(crc, (unsigned char *)sbp + sumoff + 4,	386	crc = crc32_le(crc, (unsigned char *)sbp + sumoff + 4,
387	bytes - sumoff - 4);	387	bytes - sumoff - 4);
388	return crc == le32_to_cpu(sbp->s_sum);	388	return crc == le32_to_cpu(sbp->s_sum);
389	}	389	}
390		390
391	static int nilfs_sb2_bad_offset(struct nilfs_super_block *sbp, u64 offset)	391	static int nilfs_sb2_bad_offset(struct nilfs_super_block *sbp, u64 offset)
392	{	392	{
393	return offset < ((le64_to_cpu(sbp->s_nsegments) *	393	return offset < ((le64_to_cpu(sbp->s_nsegments) *
394	le32_to_cpu(sbp->s_blocks_per_segment)) <<	394	le32_to_cpu(sbp->s_blocks_per_segment)) <<
395	(le32_to_cpu(sbp->s_log_block_size) + 10));	395	(le32_to_cpu(sbp->s_log_block_size) + 10));
396	}	396	}
397		397
398	static void nilfs_release_super_block(struct the_nilfs *nilfs)	398	static void nilfs_release_super_block(struct the_nilfs *nilfs)
399	{	399	{
400	int i;	400	int i;
401		401
402	for (i = 0; i < 2; i++) {	402	for (i = 0; i < 2; i++) {
403	if (nilfs->ns_sbp[i]) {	403	if (nilfs->ns_sbp[i]) {
404	brelse(nilfs->ns_sbh[i]);	404	brelse(nilfs->ns_sbh[i]);
405	nilfs->ns_sbh[i] = NULL;	405	nilfs->ns_sbh[i] = NULL;
406	nilfs->ns_sbp[i] = NULL;	406	nilfs->ns_sbp[i] = NULL;
407	}	407	}
408	}	408	}
409	}	409	}
410		410
411	void nilfs_fall_back_super_block(struct the_nilfs *nilfs)	411	void nilfs_fall_back_super_block(struct the_nilfs *nilfs)
412	{	412	{
413	brelse(nilfs->ns_sbh[0]);	413	brelse(nilfs->ns_sbh[0]);
414	nilfs->ns_sbh[0] = nilfs->ns_sbh[1];	414	nilfs->ns_sbh[0] = nilfs->ns_sbh[1];
415	nilfs->ns_sbp[0] = nilfs->ns_sbp[1];	415	nilfs->ns_sbp[0] = nilfs->ns_sbp[1];
416	nilfs->ns_sbh[1] = NULL;	416	nilfs->ns_sbh[1] = NULL;
417	nilfs->ns_sbp[1] = NULL;	417	nilfs->ns_sbp[1] = NULL;
418	}	418	}
419		419
420	void nilfs_swap_super_block(struct the_nilfs *nilfs)	420	void nilfs_swap_super_block(struct the_nilfs *nilfs)
421	{	421	{
422	struct buffer_head *tsbh = nilfs->ns_sbh[0];	422	struct buffer_head *tsbh = nilfs->ns_sbh[0];
423	struct nilfs_super_block *tsbp = nilfs->ns_sbp[0];	423	struct nilfs_super_block *tsbp = nilfs->ns_sbp[0];
424		424
425	nilfs->ns_sbh[0] = nilfs->ns_sbh[1];	425	nilfs->ns_sbh[0] = nilfs->ns_sbh[1];
426	nilfs->ns_sbp[0] = nilfs->ns_sbp[1];	426	nilfs->ns_sbp[0] = nilfs->ns_sbp[1];
427	nilfs->ns_sbh[1] = tsbh;	427	nilfs->ns_sbh[1] = tsbh;
428	nilfs->ns_sbp[1] = tsbp;	428	nilfs->ns_sbp[1] = tsbp;
429	}	429	}
430		430
431	static int nilfs_load_super_block(struct the_nilfs *nilfs,	431	static int nilfs_load_super_block(struct the_nilfs *nilfs,
432	struct super_block *sb, int blocksize,	432	struct super_block *sb, int blocksize,
433	struct nilfs_super_block **sbpp)	433	struct nilfs_super_block **sbpp)
434	{	434	{
435	struct nilfs_super_block **sbp = nilfs->ns_sbp;	435	struct nilfs_super_block **sbp = nilfs->ns_sbp;
436	struct buffer_head **sbh = nilfs->ns_sbh;	436	struct buffer_head **sbh = nilfs->ns_sbh;
437	u64 sb2off = NILFS_SB2_OFFSET_BYTES(nilfs->ns_bdev->bd_inode->i_size);	437	u64 sb2off = NILFS_SB2_OFFSET_BYTES(nilfs->ns_bdev->bd_inode->i_size);
438	int valid[2], swp = 0;	438	int valid[2], swp = 0;
439		439
440	sbp[0] = nilfs_read_super_block(sb, NILFS_SB_OFFSET_BYTES, blocksize,	440	sbp[0] = nilfs_read_super_block(sb, NILFS_SB_OFFSET_BYTES, blocksize,
441	&sbh[0]);	441	&sbh[0]);
442	sbp[1] = nilfs_read_super_block(sb, sb2off, blocksize, &sbh[1]);	442	sbp[1] = nilfs_read_super_block(sb, sb2off, blocksize, &sbh[1]);
443		443
444	if (!sbp[0]) {	444	if (!sbp[0]) {
445	if (!sbp[1]) {	445	if (!sbp[1]) {
446	printk(KERN_ERR "NILFS: unable to read superblock\n");	446	printk(KERN_ERR "NILFS: unable to read superblock\n");
447	return -EIO;	447	return -EIO;
448	}	448	}
449	printk(KERN_WARNING	449	printk(KERN_WARNING
450	"NILFS warning: unable to read primary superblock\n");	450	"NILFS warning: unable to read primary superblock\n");
451	} else if (!sbp[1])	451	} else if (!sbp[1])
452	printk(KERN_WARNING	452	printk(KERN_WARNING
453	"NILFS warning: unable to read secondary superblock\n");	453	"NILFS warning: unable to read secondary superblock\n");
454		454
455	valid[0] = nilfs_valid_sb(sbp[0]);	455	valid[0] = nilfs_valid_sb(sbp[0]);
456	valid[1] = nilfs_valid_sb(sbp[1]);	456	valid[1] = nilfs_valid_sb(sbp[1]);
457	swp = valid[1] &&	457	swp = valid[1] &&
458	(!valid[0] \|\|	458	(!valid[0] \|\|
459	le64_to_cpu(sbp[1]->s_wtime) > le64_to_cpu(sbp[0]->s_wtime));	459	le64_to_cpu(sbp[1]->s_wtime) > le64_to_cpu(sbp[0]->s_wtime));
460		460
461	if (valid[swp] && nilfs_sb2_bad_offset(sbp[swp], sb2off)) {	461	if (valid[swp] && nilfs_sb2_bad_offset(sbp[swp], sb2off)) {
462	brelse(sbh[1]);	462	brelse(sbh[1]);
463	sbh[1] = NULL;	463	sbh[1] = NULL;
464	sbp[1] = NULL;	464	sbp[1] = NULL;
465	swp = 0;	465	swp = 0;
466	}	466	}
467	if (!valid[swp]) {	467	if (!valid[swp]) {
468	nilfs_release_super_block(nilfs);	468	nilfs_release_super_block(nilfs);
469	printk(KERN_ERR "NILFS: Can't find nilfs on dev %s.\n",	469	printk(KERN_ERR "NILFS: Can't find nilfs on dev %s.\n",
470	sb->s_id);	470	sb->s_id);
471	return -EINVAL;	471	return -EINVAL;
472	}	472	}
473		473
474	if (swp) {	474	if (swp) {
475	printk(KERN_WARNING "NILFS warning: broken superblock. "	475	printk(KERN_WARNING "NILFS warning: broken superblock. "
476	"using spare superblock.\n");	476	"using spare superblock.\n");
477	nilfs_swap_super_block(nilfs);	477	nilfs_swap_super_block(nilfs);
478	}	478	}
479		479
480	nilfs->ns_sbwtime[0] = le64_to_cpu(sbp[0]->s_wtime);	480	nilfs->ns_sbwtime[0] = le64_to_cpu(sbp[0]->s_wtime);
481	nilfs->ns_sbwtime[1] = valid[!swp] ? le64_to_cpu(sbp[1]->s_wtime) : 0;	481	nilfs->ns_sbwtime[1] = valid[!swp] ? le64_to_cpu(sbp[1]->s_wtime) : 0;
482	nilfs->ns_prot_seq = le64_to_cpu(sbp[valid[1] & !swp]->s_last_seq);	482	nilfs->ns_prot_seq = le64_to_cpu(sbp[valid[1] & !swp]->s_last_seq);
483	*sbpp = sbp[0];	483	*sbpp = sbp[0];
484	return 0;	484	return 0;
485	}	485	}
486		486
487	/**	487	/**
488	* init_nilfs - initialize a NILFS instance.	488	* init_nilfs - initialize a NILFS instance.
489	* @nilfs: the_nilfs structure	489	* @nilfs: the_nilfs structure
490	* @sbi: nilfs_sb_info	490	* @sbi: nilfs_sb_info
491	* @sb: super block	491	* @sb: super block
492	* @data: mount options	492	* @data: mount options
493	*	493	*
494	* init_nilfs() performs common initialization per block device (e.g.	494	* init_nilfs() performs common initialization per block device (e.g.
495	* reading the super block, getting disk layout information, initializing	495	* reading the super block, getting disk layout information, initializing
496	* shared fields in the_nilfs). It takes on some portion of the jobs	496	* shared fields in the_nilfs). It takes on some portion of the jobs
497	* typically done by a fill_super() routine. This division arises from	497	* typically done by a fill_super() routine. This division arises from
498	* the nature that multiple NILFS instances may be simultaneously	498	* the nature that multiple NILFS instances may be simultaneously
499	* mounted on a device.	499	* mounted on a device.
500	* For multiple mounts on the same device, only the first mount	500	* For multiple mounts on the same device, only the first mount
501	* invokes these tasks.	501	* invokes these tasks.
502	*	502	*
503	* Return Value: On success, 0 is returned. On error, a negative error	503	* Return Value: On success, 0 is returned. On error, a negative error
504	* code is returned.	504	* code is returned.
505	*/	505	*/
506	int init_nilfs(struct the_nilfs nilfs, struct nilfs_sb_info sbi, char *data)	506	int init_nilfs(struct the_nilfs nilfs, struct nilfs_sb_info sbi, char *data)
507	{	507	{
508	struct super_block *sb = sbi->s_super;	508	struct super_block *sb = sbi->s_super;
509	struct nilfs_super_block *sbp;	509	struct nilfs_super_block *sbp;
510	struct backing_dev_info *bdi;	510	struct backing_dev_info *bdi;
511	int blocksize;	511	int blocksize;
512	int err;	512	int err;
513		513
514	down_write(&nilfs->ns_sem);	514	down_write(&nilfs->ns_sem);
515	if (nilfs_init(nilfs)) {	515	if (nilfs_init(nilfs)) {
516	/* Load values from existing the_nilfs */	516	/* Load values from existing the_nilfs */
517	sbp = nilfs->ns_sbp[0];	517	sbp = nilfs->ns_sbp[0];
518	err = nilfs_store_magic_and_option(sb, sbp, data);	518	err = nilfs_store_magic_and_option(sb, sbp, data);
519	if (err)	519	if (err)
520	goto out;	520	goto out;
521		521
522	blocksize = BLOCK_SIZE << le32_to_cpu(sbp->s_log_block_size);	522	blocksize = BLOCK_SIZE << le32_to_cpu(sbp->s_log_block_size);
523	if (sb->s_blocksize != blocksize &&	523	if (sb->s_blocksize != blocksize &&
524	!sb_set_blocksize(sb, blocksize)) {	524	!sb_set_blocksize(sb, blocksize)) {
525	printk(KERN_ERR "NILFS: blocksize %d unfit to device\n",	525	printk(KERN_ERR "NILFS: blocksize %d unfit to device\n",
526	blocksize);	526	blocksize);
527	err = -EINVAL;	527	err = -EINVAL;
528	}	528	}
529	sb->s_maxbytes = nilfs_max_size(sb->s_blocksize_bits);	529	sb->s_maxbytes = nilfs_max_size(sb->s_blocksize_bits);
530	goto out;	530	goto out;
531	}	531	}
532		532
533	blocksize = sb_min_blocksize(sb, BLOCK_SIZE);	533	blocksize = sb_min_blocksize(sb, BLOCK_SIZE);
534	if (!blocksize) {	534	if (!blocksize) {
535	printk(KERN_ERR "NILFS: unable to set blocksize\n");	535	printk(KERN_ERR "NILFS: unable to set blocksize\n");
536	err = -EINVAL;	536	err = -EINVAL;
537	goto out;	537	goto out;
538	}	538	}
539	err = nilfs_load_super_block(nilfs, sb, blocksize, &sbp);	539	err = nilfs_load_super_block(nilfs, sb, blocksize, &sbp);
540	if (err)	540	if (err)
541	goto out;	541	goto out;
542		542
543	err = nilfs_store_magic_and_option(sb, sbp, data);	543	err = nilfs_store_magic_and_option(sb, sbp, data);
544	if (err)	544	if (err)
545	goto failed_sbh;	545	goto failed_sbh;
546		546
547	blocksize = BLOCK_SIZE << le32_to_cpu(sbp->s_log_block_size);	547	blocksize = BLOCK_SIZE << le32_to_cpu(sbp->s_log_block_size);
548	if (sb->s_blocksize != blocksize) {	548	if (sb->s_blocksize != blocksize) {
549	int hw_blocksize = bdev_logical_block_size(sb->s_bdev);	549	int hw_blocksize = bdev_logical_block_size(sb->s_bdev);
550		550
551	if (blocksize < hw_blocksize) {	551	if (blocksize < hw_blocksize) {
552	printk(KERN_ERR	552	printk(KERN_ERR
553	"NILFS: blocksize %d too small for device "	553	"NILFS: blocksize %d too small for device "
554	"(sector-size = %d).\n",	554	"(sector-size = %d).\n",
555	blocksize, hw_blocksize);	555	blocksize, hw_blocksize);
556	err = -EINVAL;	556	err = -EINVAL;
557	goto failed_sbh;	557	goto failed_sbh;
558	}	558	}
559	nilfs_release_super_block(nilfs);	559	nilfs_release_super_block(nilfs);
560	sb_set_blocksize(sb, blocksize);	560	sb_set_blocksize(sb, blocksize);
561		561
562	err = nilfs_load_super_block(nilfs, sb, blocksize, &sbp);	562	err = nilfs_load_super_block(nilfs, sb, blocksize, &sbp);
563	if (err)	563	if (err)
564	goto out;	564	goto out;
565	/* not failed_sbh; sbh is released automatically	565	/* not failed_sbh; sbh is released automatically
566	when reloading fails. */	566	when reloading fails. */
567	}	567	}
568	nilfs->ns_blocksize_bits = sb->s_blocksize_bits;	568	nilfs->ns_blocksize_bits = sb->s_blocksize_bits;
569		569
570	err = nilfs_store_disk_layout(nilfs, sbp);	570	err = nilfs_store_disk_layout(nilfs, sbp);
571	if (err)	571	if (err)
572	goto failed_sbh;	572	goto failed_sbh;
573		573
574	sb->s_maxbytes = nilfs_max_size(sb->s_blocksize_bits);	574	sb->s_maxbytes = nilfs_max_size(sb->s_blocksize_bits);
575		575
576	nilfs->ns_mount_state = le16_to_cpu(sbp->s_state);	576	nilfs->ns_mount_state = le16_to_cpu(sbp->s_state);
577		577
578	bdi = nilfs->ns_bdev->bd_inode->i_mapping->backing_dev_info;	578	bdi = nilfs->ns_bdev->bd_inode->i_mapping->backing_dev_info;
579	nilfs->ns_bdi = bdi ? : &default_backing_dev_info;	579	nilfs->ns_bdi = bdi ? : &default_backing_dev_info;
580		580
581	/* Finding last segment */	581	/* Finding last segment */
582	nilfs->ns_last_pseg = le64_to_cpu(sbp->s_last_pseg);	582	nilfs->ns_last_pseg = le64_to_cpu(sbp->s_last_pseg);
583	nilfs->ns_last_cno = le64_to_cpu(sbp->s_last_cno);	583	nilfs->ns_last_cno = le64_to_cpu(sbp->s_last_cno);
584	nilfs->ns_last_seq = le64_to_cpu(sbp->s_last_seq);	584	nilfs->ns_last_seq = le64_to_cpu(sbp->s_last_seq);
585		585
586	nilfs->ns_seg_seq = nilfs->ns_last_seq;	586	nilfs->ns_seg_seq = nilfs->ns_last_seq;
587	nilfs->ns_segnum =	587	nilfs->ns_segnum =
588	nilfs_get_segnum_of_block(nilfs, nilfs->ns_last_pseg);	588	nilfs_get_segnum_of_block(nilfs, nilfs->ns_last_pseg);
589	nilfs->ns_cno = nilfs->ns_last_cno + 1;	589	nilfs->ns_cno = nilfs->ns_last_cno + 1;
590	if (nilfs->ns_segnum >= nilfs->ns_nsegments) {	590	if (nilfs->ns_segnum >= nilfs->ns_nsegments) {
591	printk(KERN_ERR "NILFS invalid last segment number.\n");	591	printk(KERN_ERR "NILFS invalid last segment number.\n");
592	err = -EINVAL;	592	err = -EINVAL;
593	goto failed_sbh;	593	goto failed_sbh;
594	}	594	}
595	/* Dummy values */	595	/* Dummy values */
596	nilfs->ns_free_segments_count =	596	nilfs->ns_free_segments_count =
597	nilfs->ns_nsegments - (nilfs->ns_segnum + 1);	597	nilfs->ns_nsegments - (nilfs->ns_segnum + 1);
598		598
599	/* Initialize gcinode cache */	599	/* Initialize gcinode cache */
600	err = nilfs_init_gccache(nilfs);	600	err = nilfs_init_gccache(nilfs);
601	if (err)	601	if (err)
602	goto failed_sbh;	602	goto failed_sbh;
603		603
604	set_nilfs_init(nilfs);	604	set_nilfs_init(nilfs);
605	err = 0;	605	err = 0;
606	out:	606	out:
607	up_write(&nilfs->ns_sem);	607	up_write(&nilfs->ns_sem);
608	return err;	608	return err;
609		609
610	failed_sbh:	610	failed_sbh:
611	nilfs_release_super_block(nilfs);	611	nilfs_release_super_block(nilfs);
612	goto out;	612	goto out;
613	}	613	}
614		614
615	int nilfs_count_free_blocks(struct the_nilfs nilfs, sector_t nblocks)	615	int nilfs_count_free_blocks(struct the_nilfs nilfs, sector_t nblocks)
616	{	616	{
617	struct inode *dat = nilfs_dat_inode(nilfs);	617	struct inode *dat = nilfs_dat_inode(nilfs);
618	unsigned long ncleansegs;	618	unsigned long ncleansegs;
619	int err;	619	int err;
620		620
621	down_read(&NILFS_MDT(dat)->mi_sem); /* XXX */	621	down_read(&NILFS_MDT(dat)->mi_sem); /* XXX */
622	err = nilfs_sufile_get_ncleansegs(nilfs->ns_sufile, &ncleansegs);	622	err = nilfs_sufile_get_ncleansegs(nilfs->ns_sufile, &ncleansegs);
623	up_read(&NILFS_MDT(dat)->mi_sem); /* XXX */	623	up_read(&NILFS_MDT(dat)->mi_sem); /* XXX */
624	if (likely(!err))	624	if (likely(!err))
625	nblocks = (sector_t)ncleansegs nilfs->ns_blocks_per_segment;	625	nblocks = (sector_t)ncleansegs nilfs->ns_blocks_per_segment;
626	return err;	626	return err;
627	}	627	}
628		628
629	int nilfs_near_disk_full(struct the_nilfs *nilfs)	629	int nilfs_near_disk_full(struct the_nilfs *nilfs)
630	{	630	{
631	struct inode *sufile = nilfs->ns_sufile;	631	struct inode *sufile = nilfs->ns_sufile;
632	unsigned long ncleansegs, nincsegs;	632	unsigned long ncleansegs, nincsegs;
633	int ret;	633	int ret;
634		634
635	ret = nilfs_sufile_get_ncleansegs(sufile, &ncleansegs);	635	ret = nilfs_sufile_get_ncleansegs(sufile, &ncleansegs);
636	if (likely(!ret)) {	636	if (likely(!ret)) {
637	nincsegs = atomic_read(&nilfs->ns_ndirtyblks) /	637	nincsegs = atomic_read(&nilfs->ns_ndirtyblks) /
638	nilfs->ns_blocks_per_segment + 1;	638	nilfs->ns_blocks_per_segment + 1;
639	if (ncleansegs <= nilfs->ns_nrsvsegs + nincsegs)	639	if (ncleansegs <= nilfs->ns_nrsvsegs + nincsegs)
640	ret++;	640	ret++;
641	}	641	}
642	return ret;	642	return ret;
643	}	643	}
644		644
645	/**	645	/**
646	* nilfs_find_sbinfo - find existing nilfs_sb_info structure	646	* nilfs_find_sbinfo - find existing nilfs_sb_info structure
647	* @nilfs: nilfs object	647	* @nilfs: nilfs object
648	* @rw_mount: mount type (non-zero value for read/write mount)	648	* @rw_mount: mount type (non-zero value for read/write mount)
649	* @cno: checkpoint number (zero for read-only mount)	649	* @cno: checkpoint number (zero for read-only mount)
650	*	650	*
651	* nilfs_find_sbinfo() returns the nilfs_sb_info structure which	651	* nilfs_find_sbinfo() returns the nilfs_sb_info structure which
652	* @rw_mount and @cno (in case of snapshots) matched. If no instance	652	* @rw_mount and @cno (in case of snapshots) matched. If no instance
653	* was found, NULL is returned. Although the super block instance can	653	* was found, NULL is returned. Although the super block instance can
654	* be unmounted after this function returns, the nilfs_sb_info struct	654	* be unmounted after this function returns, the nilfs_sb_info struct
655	* is kept on memory until nilfs_put_sbinfo() is called.	655	* is kept on memory until nilfs_put_sbinfo() is called.
656	*/	656	*/
657	struct nilfs_sb_info nilfs_find_sbinfo(struct the_nilfs nilfs,	657	struct nilfs_sb_info nilfs_find_sbinfo(struct the_nilfs nilfs,
658	int rw_mount, __u64 cno)	658	int rw_mount, __u64 cno)
659	{	659	{
660	struct nilfs_sb_info *sbi;	660	struct nilfs_sb_info *sbi;
661		661
662	down_read(&nilfs->ns_super_sem);	662	down_read(&nilfs->ns_super_sem);
663	/*	663	/*
664	* The SNAPSHOT flag and sb->s_flags are supposed to be	664	* The SNAPSHOT flag and sb->s_flags are supposed to be
665	* protected with nilfs->ns_super_sem.	665	* protected with nilfs->ns_super_sem.
666	*/	666	*/
667	sbi = nilfs->ns_current;	667	sbi = nilfs->ns_current;
668	if (rw_mount) {	668	if (rw_mount) {
669	if (sbi && !(sbi->s_super->s_flags & MS_RDONLY))	669	if (sbi && !(sbi->s_super->s_flags & MS_RDONLY))
670	goto found; /* read/write mount */	670	goto found; /* read/write mount */
671	else	671	else
672	goto out;	672	goto out;
673	} else if (cno == 0) {	673	} else if (cno == 0) {
674	if (sbi && (sbi->s_super->s_flags & MS_RDONLY))	674	if (sbi && (sbi->s_super->s_flags & MS_RDONLY))
675	goto found; /* read-only mount */	675	goto found; /* read-only mount */
676	else	676	else
677	goto out;	677	goto out;
678	}	678	}
679		679
680	list_for_each_entry(sbi, &nilfs->ns_supers, s_list) {	680	list_for_each_entry(sbi, &nilfs->ns_supers, s_list) {
681	if (nilfs_test_opt(sbi, SNAPSHOT) &&	681	if (nilfs_test_opt(sbi, SNAPSHOT) &&
682	sbi->s_snapshot_cno == cno)	682	sbi->s_snapshot_cno == cno)
683	goto found; /* snapshot mount */	683	goto found; /* snapshot mount */
684	}	684	}
685	out:	685	out:
686	up_read(&nilfs->ns_super_sem);	686	up_read(&nilfs->ns_super_sem);
687	return NULL;	687	return NULL;
688		688
689	found:	689	found:
690	atomic_inc(&sbi->s_count);	690	atomic_inc(&sbi->s_count);
691	up_read(&nilfs->ns_super_sem);	691	up_read(&nilfs->ns_super_sem);
692	return sbi;	692	return sbi;
693	}	693	}
694		694
695	int nilfs_checkpoint_is_mounted(struct the_nilfs *nilfs, __u64 cno,	695	int nilfs_checkpoint_is_mounted(struct the_nilfs *nilfs, __u64 cno,
696	int snapshot_mount)	696	int snapshot_mount)
697	{	697	{
698	struct nilfs_sb_info *sbi;	698	struct nilfs_sb_info *sbi;
699	int ret = 0;	699	int ret = 0;
700		700
701	down_read(&nilfs->ns_super_sem);	701	down_read(&nilfs->ns_super_sem);
702	if (cno == 0 \|\| cno > nilfs->ns_cno)	702	if (cno == 0 \|\| cno > nilfs->ns_cno)
703	goto out_unlock;	703	goto out_unlock;
704		704
705	list_for_each_entry(sbi, &nilfs->ns_supers, s_list) {	705	list_for_each_entry(sbi, &nilfs->ns_supers, s_list) {
706	if (sbi->s_snapshot_cno == cno &&	706	if (sbi->s_snapshot_cno == cno &&
707	(!snapshot_mount \|\| nilfs_test_opt(sbi, SNAPSHOT))) {	707	(!snapshot_mount \|\| nilfs_test_opt(sbi, SNAPSHOT))) {
708	/* exclude read-only mounts */	708	/* exclude read-only mounts */
709	ret++;	709	ret++;
710	break;	710	break;
711	}	711	}
712	}	712	}
713	/* for protecting recent checkpoints */	713	/* for protecting recent checkpoints */
714	if (cno >= nilfs_last_cno(nilfs))	714	if (cno >= nilfs_last_cno(nilfs))
715	ret++;	715	ret++;
716		716
717	out_unlock:	717	out_unlock:
718	up_read(&nilfs->ns_super_sem);	718	up_read(&nilfs->ns_super_sem);
719	return ret;	719	return ret;
720	}	720	}
721		721