[linux.git] / fs / ufs / dir.c

// SPDX-License-Identifier: GPL-2.0
/*
 *  linux/fs/ufs/ufs_dir.c
 *
 * Copyright (C) 1996
 * Adrian Rodriguez ([email protected])
 * Laboratory for Computer Science Research Computing Facility
 * Rutgers, The State University of New Jersey
 *
 * swab support by Francois-Rene Rideau <[email protected]> 19970406
 *
 * 4.4BSD (FreeBSD) support added on February 1st 1998 by
 * Niels Kristian Bech Jensen <[email protected]> partially based
 * on code by Martin von Loewis <[email protected]>.
 *
 * Migration to usage of "page cache" on May 2006 by
 * Evgeniy Dushistov <[email protected]> based on ext2 code base.
 */

#include <linux/time.h>
#include <linux/fs.h>
#include <linux/swap.h>
#include <linux/iversion.h>

#include "ufs_fs.h"
#include "ufs.h"
#include "swab.h"
#include "util.h"

/*
 * NOTE! unlike strncmp, ufs_match returns 1 for success, 0 for failure.
 *
 * len <= UFS_MAXNAMLEN and de != NULL are guaranteed by caller.
 */
static inline int ufs_match(struct super_block *sb, int len,
		const unsigned char *name, struct ufs_dir_entry *de)
{
	if (len != ufs_get_de_namlen(sb, de))
		return 0;
	if (!de->d_ino)
		return 0;
	return !memcmp(name, de->d_name, len);
}

static int ufs_commit_chunk(struct page *page, loff_t pos, unsigned len)
{
	struct address_space *mapping = page->mapping;
	struct inode *dir = mapping->host;
	int err = 0;

	inode_inc_iversion(dir);
	block_write_end(NULL, mapping, pos, len, len, page, NULL);
	if (pos+len > dir->i_size) {
		i_size_write(dir, pos+len);
		mark_inode_dirty(dir);
	}
	if (IS_DIRSYNC(dir))
		err = write_one_page(page);
	else
		unlock_page(page);
	return err;
}

static inline void ufs_put_page(struct page *page)
{
	kunmap(page);
	put_page(page);
}

ino_t ufs_inode_by_name(struct inode *dir, const struct qstr *qstr)
{
	ino_t res = 0;
	struct ufs_dir_entry *de;
	struct page *page;
	
	de = ufs_find_entry(dir, qstr, &page);
	if (de) {
		res = fs32_to_cpu(dir->i_sb, de->d_ino);
		ufs_put_page(page);
	}
	return res;
}


/* Releases the page */
void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
		  struct page *page, struct inode *inode,
		  bool update_times)
{
	loff_t pos = page_offset(page) +
			(char *) de - (char *) page_address(page);
	unsigned len = fs16_to_cpu(dir->i_sb, de->d_reclen);
	int err;

	lock_page(page);
	err = ufs_prepare_chunk(page, pos, len);
	BUG_ON(err);

	de->d_ino = cpu_to_fs32(dir->i_sb, inode->i_ino);
	ufs_set_de_type(dir->i_sb, de, inode->i_mode);

	err = ufs_commit_chunk(page, pos, len);
	ufs_put_page(page);
	if (update_times)
		dir->i_mtime = dir->i_ctime = current_time(dir);
	mark_inode_dirty(dir);
}


static bool ufs_check_page(struct page *page)
{
	struct inode *dir = page->mapping->host;
	struct super_block *sb = dir->i_sb;
	char *kaddr = page_address(page);
	unsigned offs, rec_len;
	unsigned limit = PAGE_SIZE;
	const unsigned chunk_mask = UFS_SB(sb)->s_uspi->s_dirblksize - 1;
	struct ufs_dir_entry *p;
	char *error;

	if ((dir->i_size >> PAGE_SHIFT) == page->index) {
		limit = dir->i_size & ~PAGE_MASK;
		if (limit & chunk_mask)
			goto Ebadsize;
		if (!limit)
			goto out;
	}
	for (offs = 0; offs <= limit - UFS_DIR_REC_LEN(1); offs += rec_len) {
		p = (struct ufs_dir_entry *)(kaddr + offs);
		rec_len = fs16_to_cpu(sb, p->d_reclen);

		if (rec_len < UFS_DIR_REC_LEN(1))
			goto Eshort;
		if (rec_len & 3)
			goto Ealign;
		if (rec_len < UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, p)))
			goto Enamelen;
		if (((offs + rec_len - 1) ^ offs) & ~chunk_mask)
			goto Espan;
		if (fs32_to_cpu(sb, p->d_ino) > (UFS_SB(sb)->s_uspi->s_ipg *
						  UFS_SB(sb)->s_uspi->s_ncg))
			goto Einumber;
	}
	if (offs != limit)
		goto Eend;
out:
	SetPageChecked(page);
	return true;

	/* Too bad, we had an error */

Ebadsize:
	ufs_error(sb, "ufs_check_page",
		  "size of directory #%lu is not a multiple of chunk size",
		  dir->i_ino
	);
	goto fail;
Eshort:
	error = "rec_len is smaller than minimal";
	goto bad_entry;
Ealign:
	error = "unaligned directory entry";
	goto bad_entry;
Enamelen:
	error = "rec_len is too small for name_len";
	goto bad_entry;
Espan:
	error = "directory entry across blocks";
	goto bad_entry;
Einumber:
	error = "inode out of bounds";
bad_entry:
	ufs_error (sb, "ufs_check_page", "bad entry in directory #%lu: %s - "
		   "offset=%lu, rec_len=%d, name_len=%d",
		   dir->i_ino, error, (page->index<<PAGE_SHIFT)+offs,
		   rec_len, ufs_get_de_namlen(sb, p));
	goto fail;
Eend:
	p = (struct ufs_dir_entry *)(kaddr + offs);
	ufs_error(sb, __func__,
		   "entry in directory #%lu spans the page boundary"
		   "offset=%lu",
		   dir->i_ino, (page->index<<PAGE_SHIFT)+offs);
fail:
	SetPageError(page);
	return false;
}

static struct page *ufs_get_page(struct inode *dir, unsigned long n)
{
	struct address_space *mapping = dir->i_mapping;
	struct page *page = read_mapping_page(mapping, n, NULL);
	if (!IS_ERR(page)) {
		kmap(page);
		if (unlikely(!PageChecked(page))) {
			if (PageError(page) || !ufs_check_page(page))
				goto fail;
		}
	}
	return page;

fail:
	ufs_put_page(page);
	return ERR_PTR(-EIO);
}

/*
 * Return the offset into page `page_nr' of the last valid
 * byte in that page, plus one.
 */
static unsigned
ufs_last_byte(struct inode *inode, unsigned long page_nr)
{
	unsigned last_byte = inode->i_size;

	last_byte -= page_nr << PAGE_SHIFT;
	if (last_byte > PAGE_SIZE)
		last_byte = PAGE_SIZE;
	return last_byte;
}

static inline struct ufs_dir_entry *
ufs_next_entry(struct super_block *sb, struct ufs_dir_entry *p)
{
	return (struct ufs_dir_entry *)((char *)p +
					fs16_to_cpu(sb, p->d_reclen));
}

struct ufs_dir_entry *ufs_dotdot(struct inode *dir, struct page **p)
{
	struct page *page = ufs_get_page(dir, 0);
	struct ufs_dir_entry *de = NULL;

	if (!IS_ERR(page)) {
		de = ufs_next_entry(dir->i_sb,
				    (struct ufs_dir_entry *)page_address(page));
		*p = page;
	}
	return de;
}

/*
 *	ufs_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.
 */
struct ufs_dir_entry *ufs_find_entry(struct inode *dir, const struct qstr *qstr,
				     struct page **res_page)
{
	struct super_block *sb = dir->i_sb;
	const unsigned char *name = qstr->name;
	int namelen = qstr->len;
	unsigned reclen = UFS_DIR_REC_LEN(namelen);
	unsigned long start, n;
	unsigned long npages = dir_pages(dir);
	struct page *page = NULL;
	struct ufs_inode_info *ui = UFS_I(dir);
	struct ufs_dir_entry *de;

	UFSD("ENTER, dir_ino %lu, name %s, namlen %u\n", dir->i_ino, name, namelen);

	if (npages == 0 || namelen > UFS_MAXNAMLEN)
		goto out;

	/* OFFSET_CACHE */
	*res_page = NULL;

	start = ui->i_dir_start_lookup;

	if (start >= npages)
		start = 0;
	n = start;
	do {
		char *kaddr;
		page = ufs_get_page(dir, n);
		if (!IS_ERR(page)) {
			kaddr = page_address(page);
			de = (struct ufs_dir_entry *) kaddr;
			kaddr += ufs_last_byte(dir, n) - reclen;
			while ((char *) de <= kaddr) {
				if (ufs_match(sb, namelen, name, de))
					goto found;
				de = ufs_next_entry(sb, de);
			}
			ufs_put_page(page);
		}
		if (++n >= npages)
			n = 0;
	} while (n != start);
out:
	return NULL;

found:
	*res_page = page;
	ui->i_dir_start_lookup = n;
	return de;
}

/*
 *	Parent is locked.
 */
int ufs_add_link(struct dentry *dentry, struct inode *inode)
{
	struct inode *dir = d_inode(dentry->d_parent);
	const unsigned char *name = dentry->d_name.name;
	int namelen = dentry->d_name.len;
	struct super_block *sb = dir->i_sb;
	unsigned reclen = UFS_DIR_REC_LEN(namelen);
	const unsigned int chunk_size = UFS_SB(sb)->s_uspi->s_dirblksize;
	unsigned short rec_len, name_len;
	struct page *page = NULL;
	struct ufs_dir_entry *de;
	unsigned long npages = dir_pages(dir);
	unsigned long n;
	char *kaddr;
	loff_t pos;
	int err;

	UFSD("ENTER, name %s, namelen %u\n", name, namelen);

	/*
	 * We take care of directory expansion in the same loop.
	 * This code plays outside i_size, so it locks the page
	 * to protect that region.
	 */
	for (n = 0; n <= npages; n++) {
		char *dir_end;

		page = ufs_get_page(dir, n);
		err = PTR_ERR(page);
		if (IS_ERR(page))
			goto out;
		lock_page(page);
		kaddr = page_address(page);
		dir_end = kaddr + ufs_last_byte(dir, n);
		de = (struct ufs_dir_entry *)kaddr;
		kaddr += PAGE_SIZE - reclen;
		while ((char *)de <= kaddr) {
			if ((char *)de == dir_end) {
				/* We hit i_size */
				name_len = 0;
				rec_len = chunk_size;
				de->d_reclen = cpu_to_fs16(sb, chunk_size);
				de->d_ino = 0;
				goto got_it;
			}
			if (de->d_reclen == 0) {
				ufs_error(dir->i_sb, __func__,
					  "zero-length directory entry");
				err = -EIO;
				goto out_unlock;
			}
			err = -EEXIST;
			if (ufs_match(sb, namelen, name, de))
				goto out_unlock;
			name_len = UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de));
			rec_len = fs16_to_cpu(sb, de->d_reclen);
			if (!de->d_ino && rec_len >= reclen)
				goto got_it;
			if (rec_len >= name_len + reclen)
				goto got_it;
			de = (struct ufs_dir_entry *) ((char *) de + rec_len);
		}
		unlock_page(page);
		ufs_put_page(page);
	}
	BUG();
	return -EINVAL;

got_it:
	pos = page_offset(page) +
			(char*)de - (char*)page_address(page);
	err = ufs_prepare_chunk(page, pos, rec_len);
	if (err)
		goto out_unlock;
	if (de->d_ino) {
		struct ufs_dir_entry *de1 =
			(struct ufs_dir_entry *) ((char *) de + name_len);
		de1->d_reclen = cpu_to_fs16(sb, rec_len - name_len);
		de->d_reclen = cpu_to_fs16(sb, name_len);

		de = de1;
	}

	ufs_set_de_namlen(sb, de, namelen);
	memcpy(de->d_name, name, namelen + 1);
	de->d_ino = cpu_to_fs32(sb, inode->i_ino);
	ufs_set_de_type(sb, de, inode->i_mode);

	err = ufs_commit_chunk(page, pos, rec_len);
	dir->i_mtime = dir->i_ctime = current_time(dir);

	mark_inode_dirty(dir);
	/* OFFSET_CACHE */
out_put:
	ufs_put_page(page);
out:
	return err;
out_unlock:
	unlock_page(page);
	goto out_put;
}

static inline unsigned
ufs_validate_entry(struct super_block *sb, char *base,
		   unsigned offset, unsigned mask)
{
	struct ufs_dir_entry *de = (struct ufs_dir_entry*)(base + offset);
	struct ufs_dir_entry *p = (struct ufs_dir_entry*)(base + (offset&mask));
	while ((char*)p < (char*)de)
		p = ufs_next_entry(sb, p);
	return (char *)p - base;
}


/*
 * This is blatantly stolen from ext2fs
 */
static int
ufs_readdir(struct file *file, struct dir_context *ctx)
{
	loff_t pos = ctx->pos;
	struct inode *inode = file_inode(file);
	struct super_block *sb = inode->i_sb;
	unsigned int offset = pos & ~PAGE_MASK;
	unsigned long n = pos >> PAGE_SHIFT;
	unsigned long npages = dir_pages(inode);
	unsigned chunk_mask = ~(UFS_SB(sb)->s_uspi->s_dirblksize - 1);
	bool need_revalidate = !inode_eq_iversion(inode, file->f_version);
	unsigned flags = UFS_SB(sb)->s_flags;

	UFSD("BEGIN\n");

	if (pos > inode->i_size - UFS_DIR_REC_LEN(1))
		return 0;

	for ( ; n < npages; n++, offset = 0) {
		char *kaddr, *limit;
		struct ufs_dir_entry *de;

		struct page *page = ufs_get_page(inode, n);

		if (IS_ERR(page)) {
			ufs_error(sb, __func__,
				  "bad page in #%lu",
				  inode->i_ino);
			ctx->pos += PAGE_SIZE - offset;
			return -EIO;
		}
		kaddr = page_address(page);
		if (unlikely(need_revalidate)) {
			if (offset) {
				offset = ufs_validate_entry(sb, kaddr, offset, chunk_mask);
				ctx->pos = (n<<PAGE_SHIFT) + offset;
			}
			file->f_version = inode_query_iversion(inode);
			need_revalidate = false;
		}
		de = (struct ufs_dir_entry *)(kaddr+offset);
		limit = kaddr + ufs_last_byte(inode, n) - UFS_DIR_REC_LEN(1);
		for ( ;(char*)de <= limit; de = ufs_next_entry(sb, de)) {
			if (de->d_ino) {
				unsigned char d_type = DT_UNKNOWN;

				UFSD("filldir(%s,%u)\n", de->d_name,
				      fs32_to_cpu(sb, de->d_ino));
				UFSD("namlen %u\n", ufs_get_de_namlen(sb, de));

				if ((flags & UFS_DE_MASK) == UFS_DE_44BSD)
					d_type = de->d_u.d_44.d_type;

				if (!dir_emit(ctx, de->d_name,
					       ufs_get_de_namlen(sb, de),
					       fs32_to_cpu(sb, de->d_ino),
					       d_type)) {
					ufs_put_page(page);
					return 0;
				}
			}
			ctx->pos += fs16_to_cpu(sb, de->d_reclen);
		}
		ufs_put_page(page);
	}
	return 0;
}


/*
 * ufs_delete_entry deletes a directory entry by merging it with the
 * previous entry.
 */
int ufs_delete_entry(struct inode *inode, struct ufs_dir_entry *dir,
		     struct page * page)
{
	struct super_block *sb = inode->i_sb;
	char *kaddr = page_address(page);
	unsigned from = ((char*)dir - kaddr) & ~(UFS_SB(sb)->s_uspi->s_dirblksize - 1);
	unsigned to = ((char*)dir - kaddr) + fs16_to_cpu(sb, dir->d_reclen);
	loff_t pos;
	struct ufs_dir_entry *pde = NULL;
	struct ufs_dir_entry *de = (struct ufs_dir_entry *) (kaddr + from);
	int err;

	UFSD("ENTER\n");

	UFSD("ino %u, reclen %u, namlen %u, name %s\n",
	      fs32_to_cpu(sb, de->d_ino),
	      fs16_to_cpu(sb, de->d_reclen),
	      ufs_get_de_namlen(sb, de), de->d_name);

	while ((char*)de < (char*)dir) {
		if (de->d_reclen == 0) {
			ufs_error(inode->i_sb, __func__,
				  "zero-length directory entry");
			err = -EIO;
			goto out;
		}
		pde = de;
		de = ufs_next_entry(sb, de);
	}
	if (pde)
		from = (char*)pde - (char*)page_address(page);

	pos = page_offset(page) + from;
	lock_page(page);
	err = ufs_prepare_chunk(page, pos, to - from);
	BUG_ON(err);
	if (pde)
		pde->d_reclen = cpu_to_fs16(sb, to - from);
	dir->d_ino = 0;
	err = ufs_commit_chunk(page, pos, to - from);
	inode->i_ctime = inode->i_mtime = current_time(inode);
	mark_inode_dirty(inode);
out:
	ufs_put_page(page);
	UFSD("EXIT\n");
	return err;
}

int ufs_make_empty(struct inode * inode, struct inode *dir)
{
	struct super_block * sb = dir->i_sb;
	struct address_space *mapping = inode->i_mapping;
	struct page *page = grab_cache_page(mapping, 0);
	const unsigned int chunk_size = UFS_SB(sb)->s_uspi->s_dirblksize;
	struct ufs_dir_entry * de;
	char *base;
	int err;

	if (!page)
		return -ENOMEM;

	err = ufs_prepare_chunk(page, 0, chunk_size);
	if (err) {
		unlock_page(page);
		goto fail;
	}

	kmap(page);
	base = (char*)page_address(page);
	memset(base, 0, PAGE_SIZE);

	de = (struct ufs_dir_entry *) base;

	de->d_ino = cpu_to_fs32(sb, inode->i_ino);
	ufs_set_de_type(sb, de, inode->i_mode);
	ufs_set_de_namlen(sb, de, 1);
	de->d_reclen = cpu_to_fs16(sb, UFS_DIR_REC_LEN(1));
	strcpy (de->d_name, ".");
	de = (struct ufs_dir_entry *)
		((char *)de + fs16_to_cpu(sb, de->d_reclen));
	de->d_ino = cpu_to_fs32(sb, dir->i_ino);
	ufs_set_de_type(sb, de, dir->i_mode);
	de->d_reclen = cpu_to_fs16(sb, chunk_size - UFS_DIR_REC_LEN(1));
	ufs_set_de_namlen(sb, de, 2);
	strcpy (de->d_name, "..");
	kunmap(page);

	err = ufs_commit_chunk(page, 0, chunk_size);
fail:
	put_page(page);
	return err;
}

/*
 * routine to check that the specified directory is empty (for rmdir)
 */
int ufs_empty_dir(struct inode * inode)
{
	struct super_block *sb = inode->i_sb;
	struct page *page = NULL;
	unsigned long i, npages = dir_pages(inode);

	for (i = 0; i < npages; i++) {
		char *kaddr;
		struct ufs_dir_entry *de;
		page = ufs_get_page(inode, i);

		if (IS_ERR(page))
			continue;

		kaddr = page_address(page);
		de = (struct ufs_dir_entry *)kaddr;
		kaddr += ufs_last_byte(inode, i) - UFS_DIR_REC_LEN(1);

		while ((char *)de <= kaddr) {
			if (de->d_reclen == 0) {
				ufs_error(inode->i_sb, __func__,
					"zero-length directory entry: "
					"kaddr=%p, de=%p\n", kaddr, de);
				goto not_empty;
			}
			if (de->d_ino) {
				u16 namelen=ufs_get_de_namlen(sb, de);
				/* check for . and .. */
				if (de->d_name[0] != '.')
					goto not_empty;
				if (namelen > 2)
					goto not_empty;
				if (namelen < 2) {
					if (inode->i_ino !=
					    fs32_to_cpu(sb, de->d_ino))
						goto not_empty;
				} else if (de->d_name[1] != '.')
					goto not_empty;
			}
			de = ufs_next_entry(sb, de);
		}
		ufs_put_page(page);
	}
	return 1;

not_empty:
	ufs_put_page(page);
	return 0;
}

const struct file_operations ufs_dir_operations = {
	.read		= generic_read_dir,
	.iterate_shared	= ufs_readdir,
	.fsync		= generic_file_fsync,
	.llseek		= generic_file_llseek,
};
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4 LT	2	/*
	3	* linux/fs/ufs/ufs_dir.c
	4	*
	5	* Copyright (C) 1996
	6	* Adrian Rodriguez ([email protected])
	7	* Laboratory for Computer Science Research Computing Facility
	8	* Rutgers, The State University of New Jersey
	9	*
	10	* swab support by Francois-Rene Rideau <[email protected]> 19970406
	11	*
	12	* 4.4BSD (FreeBSD) support added on February 1st 1998 by
	13	* Niels Kristian Bech Jensen <[email protected]> partially based
	14	* on code by Martin von Loewis <[email protected]>.
b71034e5 ED	15	*
	16	* Migration to usage of "page cache" on May 2006 by
	17	* Evgeniy Dushistov <[email protected]> based on ext2 code base.
1da177e4 LT	18	*/
	19
	20	#include <linux/time.h>
	21	#include <linux/fs.h>
82b9d1d0	22	#include <linux/swap.h>
bb8c2d66	23	#include <linux/iversion.h>
1da177e4	24
e5420598	25	#include "ufs_fs.h"
bcd6d4ec	26	#include "ufs.h"
1da177e4 LT	27	#include "swab.h"
	28	#include "util.h"
	29
1da177e4 LT	30	/*
	31	* NOTE! unlike strncmp, ufs_match returns 1 for success, 0 for failure.
	32	*
	33	* len <= UFS_MAXNAMLEN and de != NULL are guaranteed by caller.
	34	*/
	35	static inline int ufs_match(struct super_block *sb, int len,
89031bc7	36	const unsigned char name, struct ufs_dir_entry de)
1da177e4 LT	37	{
	38	if (len != ufs_get_de_namlen(sb, de))
	39	return 0;
	40	if (!de->d_ino)
	41	return 0;
	42	return !memcmp(name, de->d_name, len);
	43	}
	44
82b9d1d0	45	static int ufs_commit_chunk(struct page *page, loff_t pos, unsigned len)
1da177e4	46	{
82b9d1d0 NP	47	struct address_space *mapping = page->mapping;
82b9d1d0 NP	48	struct inode *dir = mapping->host;
b71034e5	49	int err = 0;
82b9d1d0	50
bb8c2d66	51	inode_inc_iversion(dir);
82b9d1d0 NP	52	block_write_end(NULL, mapping, pos, len, len, page, NULL);
	53	if (pos+len > dir->i_size) {
	54	i_size_write(dir, pos+len);
	55	mark_inode_dirty(dir);
	56	}
b71034e5	57	if (IS_DIRSYNC(dir))
2b69c828	58	err = write_one_page(page);
b71034e5 ED	59	else
	60	unlock_page(page);
	61	return err;
	62	}
1da177e4	63
b71034e5 ED	64	static inline void ufs_put_page(struct page *page)
	65	{
	66	kunmap(page);
09cbfeaf	67	put_page(page);
b71034e5	68	}
1da177e4	69
89031bc7	70	ino_t ufs_inode_by_name(struct inode dir, const struct qstr qstr)
b71034e5 ED	71	{
	72	ino_t res = 0;
	73	struct ufs_dir_entry *de;
	74	struct page *page;
	75
08049707	76	de = ufs_find_entry(dir, qstr, &page);
b71034e5 ED	77	if (de) {
	78	res = fs32_to_cpu(dir->i_sb, de->d_ino);
	79	ufs_put_page(page);
1da177e4	80	}
b71034e5	81	return res;
1da177e4 LT	82	}
1da177e4 LT	83
1da177e4	84
b71034e5 ED	85	/* Releases the page */
b71034e5 ED	86	void ufs_set_link(struct inode dir, struct ufs_dir_entry de,
70d45cdb AV	87	struct page page, struct inode inode,
70d45cdb AV	88	bool update_times)
1da177e4	89	{
82b9d1d0 NP	90	loff_t pos = page_offset(page) +
	91	(char ) de - (char ) page_address(page);
	92	unsigned len = fs16_to_cpu(dir->i_sb, de->d_reclen);
b71034e5	93	int err;
1da177e4	94
b71034e5	95	lock_page(page);
f4e420dc	96	err = ufs_prepare_chunk(page, pos, len);
b71034e5	97	BUG_ON(err);
82b9d1d0	98
b71034e5 ED	99	de->d_ino = cpu_to_fs32(dir->i_sb, inode->i_ino);
b71034e5 ED	100	ufs_set_de_type(dir->i_sb, de, inode->i_mode);
82b9d1d0 NP	101
82b9d1d0 NP	102	err = ufs_commit_chunk(page, pos, len);
b71034e5	103	ufs_put_page(page);
70d45cdb	104	if (update_times)
02027d42	105	dir->i_mtime = dir->i_ctime = current_time(dir);
b71034e5 ED	106	mark_inode_dirty(dir);
b71034e5 ED	107	}
1da177e4	108
1da177e4	109
be5b82db	110	static bool ufs_check_page(struct page *page)
b71034e5 ED	111	{
	112	struct inode *dir = page->mapping->host;
	113	struct super_block *sb = dir->i_sb;
	114	char *kaddr = page_address(page);
	115	unsigned offs, rec_len;
09cbfeaf	116	unsigned limit = PAGE_SIZE;
f336953b	117	const unsigned chunk_mask = UFS_SB(sb)->s_uspi->s_dirblksize - 1;
b71034e5 ED	118	struct ufs_dir_entry *p;
	119	char *error;
	120
09cbfeaf KS	121	if ((dir->i_size >> PAGE_SHIFT) == page->index) {
09cbfeaf KS	122	limit = dir->i_size & ~PAGE_MASK;
f336953b	123	if (limit & chunk_mask)
b71034e5 ED	124	goto Ebadsize;
	125	if (!limit)
	126	goto out;
1da177e4	127	}
b71034e5 ED	128	for (offs = 0; offs <= limit - UFS_DIR_REC_LEN(1); offs += rec_len) {
	129	p = (struct ufs_dir_entry *)(kaddr + offs);
	130	rec_len = fs16_to_cpu(sb, p->d_reclen);
	131
	132	if (rec_len < UFS_DIR_REC_LEN(1))
	133	goto Eshort;
	134	if (rec_len & 3)
	135	goto Ealign;
	136	if (rec_len < UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, p)))
	137	goto Enamelen;
f336953b	138	if (((offs + rec_len - 1) ^ offs) & ~chunk_mask)
b71034e5 ED	139	goto Espan;
	140	if (fs32_to_cpu(sb, p->d_ino) > (UFS_SB(sb)->s_uspi->s_ipg *
	141	UFS_SB(sb)->s_uspi->s_ncg))
	142	goto Einumber;
	143	}
	144	if (offs != limit)
	145	goto Eend;
	146	out:
	147	SetPageChecked(page);
be5b82db	148	return true;
b71034e5 ED	149
	150	/* Too bad, we had an error */
	151
	152	Ebadsize:
	153	ufs_error(sb, "ufs_check_page",
	154	"size of directory #%lu is not a multiple of chunk size",
	155	dir->i_ino
	156	);
	157	goto fail;
	158	Eshort:
	159	error = "rec_len is smaller than minimal";
	160	goto bad_entry;
	161	Ealign:
	162	error = "unaligned directory entry";
	163	goto bad_entry;
	164	Enamelen:
	165	error = "rec_len is too small for name_len";
	166	goto bad_entry;
	167	Espan:
	168	error = "directory entry across blocks";
	169	goto bad_entry;
	170	Einumber:
	171	error = "inode out of bounds";
	172	bad_entry:
	173	ufs_error (sb, "ufs_check_page", "bad entry in directory #%lu: %s - "
	174	"offset=%lu, rec_len=%d, name_len=%d",
09cbfeaf	175	dir->i_ino, error, (page->index<<PAGE_SHIFT)+offs,
b71034e5 ED	176	rec_len, ufs_get_de_namlen(sb, p));
	177	goto fail;
	178	Eend:
	179	p = (struct ufs_dir_entry *)(kaddr + offs);
9746077a	180	ufs_error(sb, __func__,
b71034e5 ED	181	"entry in directory #%lu spans the page boundary"
b71034e5 ED	182	"offset=%lu",
09cbfeaf	183	dir->i_ino, (page->index<<PAGE_SHIFT)+offs);
b71034e5	184	fail:
b71034e5	185	SetPageError(page);
be5b82db	186	return false;
b71034e5	187	}
1da177e4	188
b71034e5 ED	189	static struct page ufs_get_page(struct inode dir, unsigned long n)
	190	{
	191	struct address_space *mapping = dir->i_mapping;
6fe6900e	192	struct page *page = read_mapping_page(mapping, n, NULL);
b71034e5	193	if (!IS_ERR(page)) {
b71034e5	194	kmap(page);
be5b82db AV	195	if (unlikely(!PageChecked(page))) {
	196	if (PageError(page) \|\| !ufs_check_page(page))
	197	goto fail;
	198	}
1da177e4	199	}
b71034e5	200	return page;
1da177e4	201
b71034e5 ED	202	fail:
	203	ufs_put_page(page);
	204	return ERR_PTR(-EIO);
1da177e4 LT	205	}
1da177e4 LT	206
b71034e5 ED	207	/*
	208	* Return the offset into page `page_nr' of the last valid
	209	* byte in that page, plus one.
	210	*/
	211	static unsigned
	212	ufs_last_byte(struct inode *inode, unsigned long page_nr)
1da177e4	213	{
b71034e5 ED	214	unsigned last_byte = inode->i_size;
b71034e5 ED	215
09cbfeaf KS	216	last_byte -= page_nr << PAGE_SHIFT;
	217	if (last_byte > PAGE_SIZE)
	218	last_byte = PAGE_SIZE;
b71034e5	219	return last_byte;
1da177e4 LT	220	}
1da177e4 LT	221
b71034e5 ED	222	static inline struct ufs_dir_entry *
b71034e5 ED	223	ufs_next_entry(struct super_block sb, struct ufs_dir_entry p)
1da177e4	224	{
b71034e5 ED	225	return (struct ufs_dir_entry )((char )p +
b71034e5 ED	226	fs16_to_cpu(sb, p->d_reclen));
1da177e4	227	}
b71034e5 ED	228
b71034e5 ED	229	struct ufs_dir_entry ufs_dotdot(struct inode dir, struct page **p)
1da177e4	230	{
b71034e5 ED	231	struct page *page = ufs_get_page(dir, 0);
b71034e5 ED	232	struct ufs_dir_entry *de = NULL;
1da177e4	233
b71034e5 ED	234	if (!IS_ERR(page)) {
	235	de = ufs_next_entry(dir->i_sb,
	236	(struct ufs_dir_entry *)page_address(page));
	237	*p = page;
1da177e4	238	}
b71034e5	239	return de;
1da177e4 LT	240	}
1da177e4 LT	241
b71034e5 ED	242	/*
	243	* ufs_find_entry()
	244	*
	245	* finds an entry in the specified directory with the wanted name. It
	246	* returns the page in which the entry was found, and the entry itself
	247	* (as a parameter - res_dir). Page is returned mapped and unlocked.
	248	* Entry is guaranteed to be valid.
	249	*/
89031bc7	250	struct ufs_dir_entry ufs_find_entry(struct inode dir, const struct qstr *qstr,
b71034e5	251	struct page **res_page)
1da177e4	252	{
b71034e5	253	struct super_block *sb = dir->i_sb;
89031bc7	254	const unsigned char *name = qstr->name;
08049707	255	int namelen = qstr->len;
b71034e5 ED	256	unsigned reclen = UFS_DIR_REC_LEN(namelen);
b71034e5 ED	257	unsigned long start, n;
5d754ced	258	unsigned long npages = dir_pages(dir);
b71034e5	259	struct page *page = NULL;
dd187a26	260	struct ufs_inode_info *ui = UFS_I(dir);
b71034e5 ED	261	struct ufs_dir_entry *de;
b71034e5 ED	262
abf5d15f	263	UFSD("ENTER, dir_ino %lu, name %s, namlen %u\n", dir->i_ino, name, namelen);
b71034e5 ED	264
	265	if (npages == 0 \|\| namelen > UFS_MAXNAMLEN)
	266	goto out;
	267
	268	/* OFFSET_CACHE */
	269	*res_page = NULL;
	270
dd187a26 ED	271	start = ui->i_dir_start_lookup;
dd187a26 ED	272
b71034e5 ED	273	if (start >= npages)
	274	start = 0;
	275	n = start;
	276	do {
	277	char *kaddr;
	278	page = ufs_get_page(dir, n);
	279	if (!IS_ERR(page)) {
	280	kaddr = page_address(page);
	281	de = (struct ufs_dir_entry *) kaddr;
	282	kaddr += ufs_last_byte(dir, n) - reclen;
	283	while ((char *) de <= kaddr) {
b71034e5 ED	284	if (ufs_match(sb, namelen, name, de))
	285	goto found;
	286	de = ufs_next_entry(sb, de);
	287	}
	288	ufs_put_page(page);
	289	}
	290	if (++n >= npages)
	291	n = 0;
	292	} while (n != start);
	293	out:
	294	return NULL;
	295
	296	found:
	297	*res_page = page;
dd187a26	298	ui->i_dir_start_lookup = n;
b71034e5	299	return de;
1da177e4 LT	300	}
	301
	302	/*
b71034e5	303	* Parent is locked.
1da177e4 LT	304	*/
	305	int ufs_add_link(struct dentry dentry, struct inode inode)
	306	{
2b0143b5	307	struct inode *dir = d_inode(dentry->d_parent);
89031bc7	308	const unsigned char *name = dentry->d_name.name;
1da177e4	309	int namelen = dentry->d_name.len;
b71034e5 ED	310	struct super_block *sb = dir->i_sb;
b71034e5 ED	311	unsigned reclen = UFS_DIR_REC_LEN(namelen);
f336953b	312	const unsigned int chunk_size = UFS_SB(sb)->s_uspi->s_dirblksize;
b71034e5 ED	313	unsigned short rec_len, name_len;
	314	struct page *page = NULL;
	315	struct ufs_dir_entry *de;
5d754ced	316	unsigned long npages = dir_pages(dir);
b71034e5 ED	317	unsigned long n;
b71034e5 ED	318	char *kaddr;
82b9d1d0	319	loff_t pos;
1da177e4 LT	320	int err;
1da177e4 LT	321
abf5d15f	322	UFSD("ENTER, name %s, namelen %u\n", name, namelen);
b71034e5 ED	323
	324	/*
	325	* We take care of directory expansion in the same loop.
	326	* This code plays outside i_size, so it locks the page
	327	* to protect that region.
	328	*/
	329	for (n = 0; n <= npages; n++) {
	330	char *dir_end;
	331
	332	page = ufs_get_page(dir, n);
	333	err = PTR_ERR(page);
	334	if (IS_ERR(page))
	335	goto out;
	336	lock_page(page);
	337	kaddr = page_address(page);
	338	dir_end = kaddr + ufs_last_byte(dir, n);
	339	de = (struct ufs_dir_entry *)kaddr;
09cbfeaf	340	kaddr += PAGE_SIZE - reclen;
b71034e5 ED	341	while ((char *)de <= kaddr) {
	342	if ((char *)de == dir_end) {
	343	/* We hit i_size */
	344	name_len = 0;
f336953b ED	345	rec_len = chunk_size;
f336953b ED	346	de->d_reclen = cpu_to_fs16(sb, chunk_size);
b71034e5 ED	347	de->d_ino = 0;
b71034e5 ED	348	goto got_it;
1da177e4	349	}
b71034e5	350	if (de->d_reclen == 0) {
9746077a	351	ufs_error(dir->i_sb, __func__,
b71034e5 ED	352	"zero-length directory entry");
	353	err = -EIO;
	354	goto out_unlock;
	355	}
	356	err = -EEXIST;
	357	if (ufs_match(sb, namelen, name, de))
	358	goto out_unlock;
	359	name_len = UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de));
	360	rec_len = fs16_to_cpu(sb, de->d_reclen);
	361	if (!de->d_ino && rec_len >= reclen)
	362	goto got_it;
	363	if (rec_len >= name_len + reclen)
	364	goto got_it;
	365	de = (struct ufs_dir_entry ) ((char ) de + rec_len);
1da177e4	366	}
b71034e5 ED	367	unlock_page(page);
b71034e5 ED	368	ufs_put_page(page);
1da177e4	369	}
b71034e5 ED	370	BUG();
	371	return -EINVAL;
	372
	373	got_it:
82b9d1d0 NP	374	pos = page_offset(page) +
82b9d1d0 NP	375	(char)de - (char)page_address(page);
f4e420dc	376	err = ufs_prepare_chunk(page, pos, rec_len);
b71034e5 ED	377	if (err)
b71034e5 ED	378	goto out_unlock;
1da177e4	379	if (de->d_ino) {
b71034e5 ED	380	struct ufs_dir_entry *de1 =
	381	(struct ufs_dir_entry ) ((char ) de + name_len);
	382	de1->d_reclen = cpu_to_fs16(sb, rec_len - name_len);
	383	de->d_reclen = cpu_to_fs16(sb, name_len);
	384
1da177e4 LT	385	de = de1;
1da177e4 LT	386	}
b71034e5	387
1da177e4	388	ufs_set_de_namlen(sb, de, namelen);
b71034e5	389	memcpy(de->d_name, name, namelen + 1);
1da177e4 LT	390	de->d_ino = cpu_to_fs32(sb, inode->i_ino);
1da177e4 LT	391	ufs_set_de_type(sb, de, inode->i_mode);
b71034e5	392
82b9d1d0	393	err = ufs_commit_chunk(page, pos, rec_len);
02027d42	394	dir->i_mtime = dir->i_ctime = current_time(dir);
b71034e5	395
1da177e4	396	mark_inode_dirty(dir);
b71034e5 ED	397	/* OFFSET_CACHE */
	398	out_put:
	399	ufs_put_page(page);
	400	out:
	401	return err;
	402	out_unlock:
	403	unlock_page(page);
	404	goto out_put;
	405	}
	406
	407	static inline unsigned
	408	ufs_validate_entry(struct super_block sb, char base,
	409	unsigned offset, unsigned mask)
	410	{
	411	struct ufs_dir_entry de = (struct ufs_dir_entry)(base + offset);
	412	struct ufs_dir_entry p = (struct ufs_dir_entry)(base + (offset&mask));
e0d508f1	413	while ((char)p < (char)de)
b71034e5	414	p = ufs_next_entry(sb, p);
b71034e5 ED	415	return (char *)p - base;
b71034e5 ED	416	}
1da177e4	417
b71034e5 ED	418
	419	/*
	420	* This is blatantly stolen from ext2fs
	421	*/
	422	static int
80886298	423	ufs_readdir(struct file file, struct dir_context ctx)
b71034e5	424	{
80886298 AV	425	loff_t pos = ctx->pos;
80886298 AV	426	struct inode *inode = file_inode(file);
b71034e5	427	struct super_block *sb = inode->i_sb;
09cbfeaf KS	428	unsigned int offset = pos & ~PAGE_MASK;
09cbfeaf KS	429	unsigned long n = pos >> PAGE_SHIFT;
5d754ced	430	unsigned long npages = dir_pages(inode);
f336953b	431	unsigned chunk_mask = ~(UFS_SB(sb)->s_uspi->s_dirblksize - 1);
c472c07b	432	bool need_revalidate = !inode_eq_iversion(inode, file->f_version);
b71034e5 ED	433	unsigned flags = UFS_SB(sb)->s_flags;
b71034e5 ED	434
abf5d15f	435	UFSD("BEGIN\n");
b71034e5 ED	436
	437	if (pos > inode->i_size - UFS_DIR_REC_LEN(1))
	438	return 0;
	439
	440	for ( ; n < npages; n++, offset = 0) {
	441	char kaddr, limit;
	442	struct ufs_dir_entry *de;
	443
	444	struct page *page = ufs_get_page(inode, n);
	445
	446	if (IS_ERR(page)) {
9746077a	447	ufs_error(sb, __func__,
b71034e5 ED	448	"bad page in #%lu",
b71034e5 ED	449	inode->i_ino);
09cbfeaf	450	ctx->pos += PAGE_SIZE - offset;
b71034e5 ED	451	return -EIO;
	452	}
	453	kaddr = page_address(page);
	454	if (unlikely(need_revalidate)) {
	455	if (offset) {
	456	offset = ufs_validate_entry(sb, kaddr, offset, chunk_mask);
09cbfeaf	457	ctx->pos = (n<<PAGE_SHIFT) + offset;
b71034e5	458	}
bb8c2d66 JL	459	file->f_version = inode_query_iversion(inode);
bb8c2d66 JL	460	need_revalidate = false;
b71034e5 ED	461	}
	462	de = (struct ufs_dir_entry *)(kaddr+offset);
	463	limit = kaddr + ufs_last_byte(inode, n) - UFS_DIR_REC_LEN(1);
	464	for ( ;(char*)de <= limit; de = ufs_next_entry(sb, de)) {
b71034e5	465	if (de->d_ino) {
b71034e5 ED	466	unsigned char d_type = DT_UNKNOWN;
b71034e5 ED	467
abf5d15f ED	468	UFSD("filldir(%s,%u)\n", de->d_name,
	469	fs32_to_cpu(sb, de->d_ino));
	470	UFSD("namlen %u\n", ufs_get_de_namlen(sb, de));
b71034e5 ED	471
	472	if ((flags & UFS_DE_MASK) == UFS_DE_44BSD)
	473	d_type = de->d_u.d_44.d_type;
	474
80886298	475	if (!dir_emit(ctx, de->d_name,
b71034e5	476	ufs_get_de_namlen(sb, de),
80886298 AV	477	fs32_to_cpu(sb, de->d_ino),
80886298 AV	478	d_type)) {
b71034e5 ED	479	ufs_put_page(page);
	480	return 0;
	481	}
	482	}
80886298	483	ctx->pos += fs16_to_cpu(sb, de->d_reclen);
b71034e5 ED	484	}
	485	ufs_put_page(page);
	486	}
1da177e4 LT	487	return 0;
	488	}
	489
b71034e5	490
1da177e4 LT	491	/*
	492	* ufs_delete_entry deletes a directory entry by merging it with the
	493	* previous entry.
	494	*/
b71034e5 ED	495	int ufs_delete_entry(struct inode inode, struct ufs_dir_entry dir,
b71034e5 ED	496	struct page * page)
1da177e4	497	{
b71034e5	498	struct super_block *sb = inode->i_sb;
b71034e5	499	char *kaddr = page_address(page);
f336953b	500	unsigned from = ((char*)dir - kaddr) & ~(UFS_SB(sb)->s_uspi->s_dirblksize - 1);
b71034e5	501	unsigned to = ((char*)dir - kaddr) + fs16_to_cpu(sb, dir->d_reclen);
82b9d1d0	502	loff_t pos;
b71034e5 ED	503	struct ufs_dir_entry *pde = NULL;
	504	struct ufs_dir_entry de = (struct ufs_dir_entry ) (kaddr + from);
	505	int err;
1da177e4	506
abf5d15f	507	UFSD("ENTER\n");
1da177e4	508
abf5d15f	509	UFSD("ino %u, reclen %u, namlen %u, name %s\n",
b71034e5 ED	510	fs32_to_cpu(sb, de->d_ino),
b71034e5 ED	511	fs16_to_cpu(sb, de->d_reclen),
abf5d15f	512	ufs_get_de_namlen(sb, de), de->d_name);
b71034e5 ED	513
	514	while ((char)de < (char)dir) {
	515	if (de->d_reclen == 0) {
9746077a	516	ufs_error(inode->i_sb, __func__,
b71034e5 ED	517	"zero-length directory entry");
	518	err = -EIO;
	519	goto out;
1da177e4	520	}
b71034e5 ED	521	pde = de;
b71034e5 ED	522	de = ufs_next_entry(sb, de);
1da177e4	523	}
b71034e5 ED	524	if (pde)
b71034e5 ED	525	from = (char)pde - (char)page_address(page);
82b9d1d0 NP	526
82b9d1d0 NP	527	pos = page_offset(page) + from;
b71034e5	528	lock_page(page);
f4e420dc	529	err = ufs_prepare_chunk(page, pos, to - from);
b71034e5 ED	530	BUG_ON(err);
b71034e5 ED	531	if (pde)
82b9d1d0	532	pde->d_reclen = cpu_to_fs16(sb, to - from);
b71034e5	533	dir->d_ino = 0;
82b9d1d0	534	err = ufs_commit_chunk(page, pos, to - from);
02027d42	535	inode->i_ctime = inode->i_mtime = current_time(inode);
b71034e5 ED	536	mark_inode_dirty(inode);
	537	out:
	538	ufs_put_page(page);
abf5d15f	539	UFSD("EXIT\n");
b71034e5	540	return err;
1da177e4 LT	541	}
	542
	543	int ufs_make_empty(struct inode * inode, struct inode *dir)
	544	{
	545	struct super_block * sb = dir->i_sb;
b71034e5 ED	546	struct address_space *mapping = inode->i_mapping;
b71034e5 ED	547	struct page *page = grab_cache_page(mapping, 0);
f336953b	548	const unsigned int chunk_size = UFS_SB(sb)->s_uspi->s_dirblksize;
1da177e4	549	struct ufs_dir_entry * de;
b71034e5	550	char *base;
1da177e4 LT	551	int err;
1da177e4 LT	552
b71034e5 ED	553	if (!page)
b71034e5 ED	554	return -ENOMEM;
82b9d1d0	555
f4e420dc	556	err = ufs_prepare_chunk(page, 0, chunk_size);
b71034e5 ED	557	if (err) {
	558	unlock_page(page);
	559	goto fail;
	560	}
	561
82b9d1d0	562	kmap(page);
b71034e5	563	base = (char*)page_address(page);
09cbfeaf	564	memset(base, 0, PAGE_SIZE);
b71034e5 ED	565
b71034e5 ED	566	de = (struct ufs_dir_entry *) base;
1da177e4	567
1da177e4 LT	568	de->d_ino = cpu_to_fs32(sb, inode->i_ino);
	569	ufs_set_de_type(sb, de, inode->i_mode);
	570	ufs_set_de_namlen(sb, de, 1);
	571	de->d_reclen = cpu_to_fs16(sb, UFS_DIR_REC_LEN(1));
	572	strcpy (de->d_name, ".");
	573	de = (struct ufs_dir_entry *)
	574	((char *)de + fs16_to_cpu(sb, de->d_reclen));
	575	de->d_ino = cpu_to_fs32(sb, dir->i_ino);
	576	ufs_set_de_type(sb, de, dir->i_mode);
f336953b	577	de->d_reclen = cpu_to_fs16(sb, chunk_size - UFS_DIR_REC_LEN(1));
1da177e4 LT	578	ufs_set_de_namlen(sb, de, 2);
1da177e4 LT	579	strcpy (de->d_name, "..");
82b9d1d0	580	kunmap(page);
b71034e5	581
f336953b	582	err = ufs_commit_chunk(page, 0, chunk_size);
b71034e5	583	fail:
09cbfeaf	584	put_page(page);
b71034e5	585	return err;
1da177e4 LT	586	}
	587
	588	/*
	589	* routine to check that the specified directory is empty (for rmdir)
	590	*/
b71034e5	591	int ufs_empty_dir(struct inode * inode)
1da177e4	592	{
b71034e5 ED	593	struct super_block *sb = inode->i_sb;
b71034e5 ED	594	struct page *page = NULL;
5d754ced	595	unsigned long i, npages = dir_pages(inode);
b71034e5 ED	596
	597	for (i = 0; i < npages; i++) {
	598	char *kaddr;
	599	struct ufs_dir_entry *de;
	600	page = ufs_get_page(inode, i);
	601
	602	if (IS_ERR(page))
	603	continue;
	604
	605	kaddr = page_address(page);
	606	de = (struct ufs_dir_entry *)kaddr;
	607	kaddr += ufs_last_byte(inode, i) - UFS_DIR_REC_LEN(1);
	608
	609	while ((char *)de <= kaddr) {
	610	if (de->d_reclen == 0) {
9746077a	611	ufs_error(inode->i_sb, __func__,
b71034e5 ED	612	"zero-length directory entry: "
	613	"kaddr=%p, de=%p\n", kaddr, de);
	614	goto not_empty;
1da177e4	615	}
b71034e5 ED	616	if (de->d_ino) {
	617	u16 namelen=ufs_get_de_namlen(sb, de);
	618	/* check for . and .. */
	619	if (de->d_name[0] != '.')
	620	goto not_empty;
	621	if (namelen > 2)
	622	goto not_empty;
	623	if (namelen < 2) {
	624	if (inode->i_ino !=
	625	fs32_to_cpu(sb, de->d_ino))
	626	goto not_empty;
	627	} else if (de->d_name[1] != '.')
	628	goto not_empty;
	629	}
	630	de = ufs_next_entry(sb, de);
1da177e4	631	}
b71034e5	632	ufs_put_page(page);
1da177e4	633	}
1da177e4	634	return 1;
b71034e5 ED	635
	636	not_empty:
	637	ufs_put_page(page);
	638	return 0;
1da177e4 LT	639	}
1da177e4 LT	640
4b6f5d20	641	const struct file_operations ufs_dir_operations = {
1da177e4	642	.read = generic_read_dir,
3b0a3c1a	643	.iterate_shared = ufs_readdir,
1b061d92	644	.fsync = generic_file_fsync,
3222a3e5	645	.llseek = generic_file_llseek,
1da177e4	646	};