Commit 6f133c97 authored by Matthew Wilcox (Oracle)'s avatar Matthew Wilcox (Oracle) Committed by Andrew Morton
Browse files

nilfs2: convert nilfs_rename() to use folios 

This involves converting nilfs_find_entry(), nilfs_dotdot(),
nilfs_set_link(), nilfs_delete_entry() and nilfs_do_unlink() to use folios
as well.

[konishi.ryusuke: followed the change of page release helper call sites]
Link: https://lkml.kernel.org/r/20231127143036.2425-13-konishi.ryusuke@gmail.com


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

fs/nilfs2/dir.c

+32 −36
Original line number Diff line number Diff line
@@ -325,36 +325,33 @@ static int nilfs_readdir(struct file *file, struct dir_context *ctx) 
/*

 * nilfs_find_entry()

 *

 * finds an entry in the specified directory with the wanted name. It

 * returns the page in which the entry was found, and the entry itself

 * (as a parameter - res_dir). Page is returned mapped and unlocked.

 * Entry is guaranteed to be valid.

 * Finds an entry in the specified directory with the wanted name. It

 * returns the folio in which the entry was found, and the entry itself.

 * The folio is mapped and unlocked.  When the caller is finished with

 * the entry, it should call folio_release_kmap().

 *

 * On failure, returns NULL and the caller should ignore foliop.

 */

struct nilfs_dir_entry *

nilfs_find_entry(struct inode *dir, const struct qstr *qstr,

		 struct page **res_page)

struct nilfs_dir_entry *nilfs_find_entry(struct inode *dir,

		const struct qstr *qstr, struct folio **foliop)

{

	const unsigned char *name = qstr->name;

	int namelen = qstr->len;

	unsigned int reclen = NILFS_DIR_REC_LEN(namelen);

	unsigned long start, n;

	unsigned long npages = dir_pages(dir);

	struct folio *folio = NULL;

	struct nilfs_inode_info *ei = NILFS_I(dir);

	struct nilfs_dir_entry *de;



	if (npages == 0)

		goto out;



	/* OFFSET_CACHE */

	*res_page = NULL;



	start = ei->i_dir_start_lookup;

	if (start >= npages)

		start = 0;

	n = start;

	do {

		char *kaddr = nilfs_get_folio(dir, n, &folio);

		char *kaddr = nilfs_get_folio(dir, n, foliop);



		if (!IS_ERR(kaddr)) {

			de = (struct nilfs_dir_entry *)kaddr;
@@ -363,14 +360,14 @@ nilfs_find_entry(struct inode *dir, const struct qstr *qstr, 
				if (de->rec_len == 0) {

					nilfs_error(dir->i_sb,

						"zero-length directory entry");

					folio_release_kmap(folio, kaddr);

					folio_release_kmap(*foliop, kaddr);

					goto out;

				}

				if (nilfs_match(namelen, name, de))

					goto found;

				de = nilfs_next_entry(de);

			}

			folio_release_kmap(folio, kaddr);

			folio_release_kmap(*foliop, kaddr);

		}

		if (++n >= npages)

			n = 0;
@@ -387,14 +384,13 @@ nilfs_find_entry(struct inode *dir, const struct qstr *qstr, 
	return NULL;



found:

	*res_page = &folio->page;

	ei->i_dir_start_lookup = n;

	return de;

}



struct nilfs_dir_entry *nilfs_dotdot(struct inode *dir, struct page **p)

struct nilfs_dir_entry *nilfs_dotdot(struct inode *dir, struct folio **foliop)

{

	struct nilfs_dir_entry *de = nilfs_get_page(dir, 0, p);

	struct nilfs_dir_entry *de = nilfs_get_folio(dir, 0, foliop);



	if (IS_ERR(de))

		return NULL;
@@ -405,30 +401,30 @@ ino_t nilfs_inode_by_name(struct inode *dir, const struct qstr *qstr) 
{

	ino_t res = 0;

	struct nilfs_dir_entry *de;

	struct page *page;

	struct folio *folio;



	de = nilfs_find_entry(dir, qstr, &page);

	de = nilfs_find_entry(dir, qstr, &folio);

	if (de) {

		res = le64_to_cpu(de->inode);

		unmap_and_put_page(page, de);

		folio_release_kmap(folio, de);

	}

	return res;

}



void nilfs_set_link(struct inode *dir, struct nilfs_dir_entry *de,

		    struct page *page, struct inode *inode)

		    struct folio *folio, struct inode *inode)

{

	unsigned int from = offset_in_page(de);

	unsigned int to = from + nilfs_rec_len_from_disk(de->rec_len);

	struct address_space *mapping = page->mapping;

	size_t from = offset_in_folio(folio, de);

	size_t to = from + nilfs_rec_len_from_disk(de->rec_len);

	struct address_space *mapping = folio->mapping;

	int err;



	lock_page(page);

	err = nilfs_prepare_chunk(page, from, to);

	folio_lock(folio);

	err = nilfs_prepare_chunk(&folio->page, from, to);

	BUG_ON(err);

	de->inode = cpu_to_le64(inode->i_ino);

	nilfs_set_de_type(de, inode);

	nilfs_commit_chunk(page, mapping, from, to);

	nilfs_commit_chunk(&folio->page, mapping, from, to);

	inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));

}
@@ -532,14 +528,14 @@ int nilfs_add_link(struct dentry *dentry, struct inode *inode) 


/*

 * nilfs_delete_entry deletes a directory entry by merging it with the

 * previous entry. Page is up-to-date.

 * previous entry. Folio is up-to-date.

 */

int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct page *page)

int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct folio *folio)

{

	struct address_space *mapping = page->mapping;

	struct address_space *mapping = folio->mapping;

	struct inode *inode = mapping->host;

	char *kaddr = (char *)((unsigned long)dir & PAGE_MASK);

	unsigned int from, to;

	char *kaddr = (char *)((unsigned long)dir & ~(folio_size(folio) - 1));

	size_t from, to;

	struct nilfs_dir_entry *de, *pde = NULL;

	int err;
@@ -559,13 +555,13 @@ int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct page *page) 
	}

	if (pde)

		from = (char *)pde - kaddr;

	lock_page(page);

	err = nilfs_prepare_chunk(page, from, to);

	folio_lock(folio);

	err = nilfs_prepare_chunk(&folio->page, from, to);

	BUG_ON(err);

	if (pde)

		pde->rec_len = nilfs_rec_len_to_disk(to - from);

	dir->inode = 0;

	nilfs_commit_chunk(page, mapping, from, to);

	nilfs_commit_chunk(&folio->page, mapping, from, to);

	inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));

out:

	return err;

fs/nilfs2/namei.c

+18 −18
Original line number Diff line number Diff line
@@ -260,11 +260,11 @@ static int nilfs_do_unlink(struct inode *dir, struct dentry *dentry) 
{

	struct inode *inode;

	struct nilfs_dir_entry *de;

	struct page *page;

	struct folio *folio;

	int err;



	err = -ENOENT;

	de = nilfs_find_entry(dir, &dentry->d_name, &page);

	de = nilfs_find_entry(dir, &dentry->d_name, &folio);

	if (!de)

		goto out;
@@ -279,8 +279,8 @@ static int nilfs_do_unlink(struct inode *dir, struct dentry *dentry) 
			   inode->i_ino, inode->i_nlink);

		set_nlink(inode, 1);

	}

	err = nilfs_delete_entry(de, page);

	unmap_and_put_page(page, de);

	err = nilfs_delete_entry(de, folio);

	folio_release_kmap(folio, de);

	if (err)

		goto out;
@@ -348,9 +348,9 @@ static int nilfs_rename(struct mnt_idmap *idmap, 
{

	struct inode *old_inode = d_inode(old_dentry);

	struct inode *new_inode = d_inode(new_dentry);

	struct page *dir_page = NULL;

	struct folio *dir_folio = NULL;

	struct nilfs_dir_entry *dir_de = NULL;

	struct page *old_page;

	struct folio *old_folio;

	struct nilfs_dir_entry *old_de;

	struct nilfs_transaction_info ti;

	int err;
@@ -363,19 +363,19 @@ static int nilfs_rename(struct mnt_idmap *idmap, 
		return err;



	err = -ENOENT;

	old_de = nilfs_find_entry(old_dir, &old_dentry->d_name, &old_page);

	old_de = nilfs_find_entry(old_dir, &old_dentry->d_name, &old_folio);

	if (!old_de)

		goto out;



	if (S_ISDIR(old_inode->i_mode)) {

		err = -EIO;

		dir_de = nilfs_dotdot(old_inode, &dir_page);

		dir_de = nilfs_dotdot(old_inode, &dir_folio);

		if (!dir_de)

			goto out_old;

	}



	if (new_inode) {

		struct page *new_page;

		struct folio *new_folio;

		struct nilfs_dir_entry *new_de;



		err = -ENOTEMPTY;
@@ -383,11 +383,11 @@ static int nilfs_rename(struct mnt_idmap *idmap, 
			goto out_dir;



		err = -ENOENT;

		new_de = nilfs_find_entry(new_dir, &new_dentry->d_name, &new_page);

		new_de = nilfs_find_entry(new_dir, &new_dentry->d_name, &new_folio);

		if (!new_de)

			goto out_dir;

		nilfs_set_link(new_dir, new_de, new_page, old_inode);

		unmap_and_put_page(new_page, new_de);

		nilfs_set_link(new_dir, new_de, new_folio, old_inode);

		folio_release_kmap(new_folio, new_de);

		nilfs_mark_inode_dirty(new_dir);

		inode_set_ctime_current(new_inode);

		if (dir_de)
@@ -410,14 +410,14 @@ static int nilfs_rename(struct mnt_idmap *idmap, 
	 */

	inode_set_ctime_current(old_inode);



	nilfs_delete_entry(old_de, old_page);

	nilfs_delete_entry(old_de, old_folio);



	if (dir_de) {

		nilfs_set_link(old_inode, dir_de, dir_page, new_dir);

		unmap_and_put_page(dir_page, dir_de);

		nilfs_set_link(old_inode, dir_de, dir_folio, new_dir);

		folio_release_kmap(dir_folio, dir_de);

		drop_nlink(old_dir);

	}

	unmap_and_put_page(old_page, old_de);

	folio_release_kmap(old_folio, old_de);



	nilfs_mark_inode_dirty(old_dir);

	nilfs_mark_inode_dirty(old_inode);
@@ -427,9 +427,9 @@ static int nilfs_rename(struct mnt_idmap *idmap, 


out_dir:

	if (dir_de)

		unmap_and_put_page(dir_page, dir_de);

		folio_release_kmap(dir_folio, dir_de);

out_old:

	unmap_and_put_page(old_page, old_de);

	folio_release_kmap(old_folio, old_de);

out:

	nilfs_transaction_abort(old_dir->i_sb);

	return err;

fs/nilfs2/nilfs.h

+10 −10
Original line number Diff line number Diff line
@@ -226,16 +226,16 @@ static inline __u32 nilfs_mask_flags(umode_t mode, __u32 flags) 
}



/* dir.c */

extern int nilfs_add_link(struct dentry *, struct inode *);

extern ino_t nilfs_inode_by_name(struct inode *, const struct qstr *);

extern int nilfs_make_empty(struct inode *, struct inode *);

extern struct nilfs_dir_entry *

nilfs_find_entry(struct inode *, const struct qstr *, struct page **);

extern int nilfs_delete_entry(struct nilfs_dir_entry *, struct page *);

extern int nilfs_empty_dir(struct inode *);

extern struct nilfs_dir_entry *nilfs_dotdot(struct inode *, struct page **);

extern void nilfs_set_link(struct inode *, struct nilfs_dir_entry *,

			   struct page *, struct inode *);

int nilfs_add_link(struct dentry *, struct inode *);

ino_t nilfs_inode_by_name(struct inode *, const struct qstr *);

int nilfs_make_empty(struct inode *, struct inode *);

struct nilfs_dir_entry *nilfs_find_entry(struct inode *, const struct qstr *,

		struct folio **);

int nilfs_delete_entry(struct nilfs_dir_entry *, struct folio *);

int nilfs_empty_dir(struct inode *);

struct nilfs_dir_entry *nilfs_dotdot(struct inode *, struct folio **);

void nilfs_set_link(struct inode *, struct nilfs_dir_entry *,

			   struct folio *, struct inode *);



/* file.c */

extern int nilfs_sync_file(struct file *, loff_t, loff_t, int);