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

/*
 *  linux/fs/ufs/ufs_dir.c
 *
 * Copyright (C) 1996
 * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
 * Laboratory for Computer Science Research Computing Facility
 * Rutgers, The State University of New Jersey
 *
 * swab support by Francois-Rene Rideau <fare@tunes.org> 19970406
 *
 * 4.4BSD (FreeBSD) support added on February 1st 1998 by
 * Niels Kristian Bech Jensen <nkbj@image.dk> partially based
 * on code by Martin von Loewis <martin@mira.isdn.cs.tu-berlin.de>.
 *
 * Migration to usage of "page cache" on May 2006 by
 * Evgeniy Dushistov <dushistov@mail.ru> based on ext2 code base.
 */

#include <linux/time.h>
#include <linux/fs.h>
#include <linux/ufs_fs.h>
#include <linux/smp_lock.h>
#include <linux/sched.h>

#include "swab.h"
#include "util.h"

#undef UFS_DIR_DEBUG

#ifdef UFS_DIR_DEBUG
#define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x;
#else
#define UFSD(x)
#endif

/*
 * 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 char * const 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, unsigned from, unsigned to)
{
	struct inode *dir = page->mapping->host;
	int err = 0;
	dir->i_version++;
	page->mapping->a_ops->commit_write(NULL, page, from, to);
	if (IS_DIRSYNC(dir))
		err = write_one_page(page, 1);
	else
		unlock_page(page);
	return err;
}

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

static inline unsigned long ufs_dir_pages(struct inode *inode)
{
	return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
}

ino_t ufs_inode_by_name(struct inode *dir, struct dentry *dentry)
{
	ino_t res = 0;
	struct ufs_dir_entry *de;
	struct page *page;
	
	de = ufs_find_entry(dir, dentry, &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)
{
	unsigned from = (char *) de - (char *) page_address(page);
	unsigned to = from + fs16_to_cpu(dir->i_sb, de->d_reclen);
	int err;

	lock_page(page);
	err = page->mapping->a_ops->prepare_write(NULL, page, from, to);
	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, from, to);
	ufs_put_page(page);
	dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
	mark_inode_dirty(dir);
}


static void 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_CACHE_SIZE;
	struct ufs_dir_entry *p;
	char *error;

	if ((dir->i_size >> PAGE_CACHE_SHIFT) == page->index) {
		limit = dir->i_size & ~PAGE_CACHE_MASK;
		if (limit & (UFS_SECTOR_SIZE - 1))
			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) & ~(UFS_SECTOR_SIZE-1))
			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;

	/* 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_CACHE_SHIFT)+offs,
		   rec_len, ufs_get_de_namlen(sb, p));
	goto fail;
Eend:
	p = (struct ufs_dir_entry *)(kaddr + offs);
	ufs_error (sb, "ext2_check_page",
		   "entry in directory #%lu spans the page boundary"
		   "offset=%lu",
		   dir->i_ino, (page->index<<PAGE_CACHE_SHIFT)+offs);
fail:
	SetPageChecked(page);
	SetPageError(page);
}

static struct page *ufs_get_page(struct inode *dir, unsigned long n)
{
	struct address_space *mapping = dir->i_mapping;
	struct page *page = read_cache_page(mapping, n,
				(filler_t*)mapping->a_ops->readpage, NULL);
	if (!IS_ERR(page)) {
		wait_on_page_locked(page);
		kmap(page);
		if (!PageUptodate(page))
			goto fail;
		if (!PageChecked(page))
			ufs_check_page(page);
		if (PageError(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_CACHE_SHIFT;
	if (last_byte > PAGE_CACHE_SIZE)
		last_byte = PAGE_CACHE_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, struct dentry *dentry,
				     struct page **res_page)
{
	struct super_block *sb = dir->i_sb;
	const char *name = dentry->d_name.name;
	int namelen = dentry->d_name.len;
	unsigned reclen = UFS_DIR_REC_LEN(namelen);
	unsigned long start, n;
	unsigned long npages = ufs_dir_pages(dir);
	struct page *page = NULL;
	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 = ei->i_dir_start_lookup; */
	start = 0;
	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 (de->d_reclen == 0) {
					ufs_error(dir->i_sb, __FUNCTION__,
						  "zero-length directory entry");
					ufs_put_page(page);
					goto out;
				}
				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;
	/* ei->i_dir_start_lookup = n; */
	return de;
}

/*
 *	Parent is locked.
 */
int ufs_add_link(struct dentry *dentry, struct inode *inode)
{
	struct inode *dir = dentry->d_parent->d_inode;
	const 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);
	unsigned short rec_len, name_len;
	struct page *page = NULL;
	struct ufs_dir_entry *de;
	unsigned long npages = ufs_dir_pages(dir);
	unsigned long n;
	char *kaddr;
	unsigned from, to;
	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_CACHE_SIZE - reclen;
		while ((char *)de <= kaddr) {
			if ((char *)de == dir_end) {
				/* We hit i_size */
				name_len = 0;
				rec_len = UFS_SECTOR_SIZE;
				de->d_reclen = cpu_to_fs16(sb, UFS_SECTOR_SIZE);
				de->d_ino = 0;
				goto got_it;
			}
			if (de->d_reclen == 0) {
				ufs_error(dir->i_sb, __FUNCTION__,
					  "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:
	from = (char*)de - (char*)page_address(page);
	to = from + rec_len;
	err = page->mapping->a_ops->prepare_write(NULL, page, from, to);
	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, from, to);
	dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;

	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) {
		if (p->d_reclen == 0)
			break;
		p = ufs_next_entry(sb, p);
	}
	return (char *)p - base;
}


/*
 * This is blatantly stolen from ext2fs
 */
static int
ufs_readdir(struct file *filp, void *dirent, filldir_t filldir)
{
	loff_t pos = filp->f_pos;
	struct inode *inode = filp->f_dentry->d_inode;
	struct super_block *sb = inode->i_sb;
	unsigned int offset = pos & ~PAGE_CACHE_MASK;
	unsigned long n = pos >> PAGE_CACHE_SHIFT;
	unsigned long npages = ufs_dir_pages(inode);
	unsigned chunk_mask = ~(UFS_SECTOR_SIZE - 1);
	int need_revalidate = filp->f_version != inode->i_version;
	unsigned flags = UFS_SB(sb)->s_flags;

	UFSD(("BEGIN"));

	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, __FUNCTION__,
				  "bad page in #%lu",
				  inode->i_ino);
			filp->f_pos += PAGE_CACHE_SIZE - offset;
			return -EIO;
		}
		kaddr = page_address(page);
		if (unlikely(need_revalidate)) {
			if (offset) {
				offset = ufs_validate_entry(sb, kaddr, offset, chunk_mask);
				filp->f_pos = (n<<PAGE_CACHE_SHIFT) + offset;
			}
			filp->f_version = inode->i_version;
			need_revalidate = 0;
		}
		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_reclen == 0) {
				ufs_error(sb, __FUNCTION__,
					"zero-length directory entry");
				ufs_put_page(page);
				return -EIO;
			}
			if (de->d_ino) {
				int over;
				unsigned char d_type = DT_UNKNOWN;

				offset = (char *)de - kaddr;

				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;

				over = filldir(dirent, de->d_name,
					       ufs_get_de_namlen(sb, de),
						(n<<PAGE_CACHE_SHIFT) | offset,
					       fs32_to_cpu(sb, de->d_ino), d_type);
				if (over) {
					ufs_put_page(page);
					return 0;
				}
			}
			filp->f_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;
	struct address_space *mapping = page->mapping;
	char *kaddr = page_address(page);
	unsigned from = ((char*)dir - kaddr) & ~(UFS_SECTOR_SIZE - 1);
	unsigned to = ((char*)dir - kaddr) + fs16_to_cpu(sb, dir->d_reclen);
	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, __FUNCTION__,
				  "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);
	lock_page(page);
	err = mapping->a_ops->prepare_write(NULL, page, from, to);
	BUG_ON(err);
	if (pde)
		pde->d_reclen = cpu_to_fs16(sb, to-from);
	dir->d_ino = 0;
	err = ufs_commit_chunk(page, from, to);
	inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
	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);
	struct ufs_dir_entry * de;
	char *base;
	int err;

	if (!page)
		return -ENOMEM;
	kmap(page);
	err = mapping->a_ops->prepare_write(NULL, page, 0, UFS_SECTOR_SIZE);
	if (err) {
		unlock_page(page);
		goto fail;
	}


	base = (char*)page_address(page);
	memset(base, 0, PAGE_CACHE_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, UFS_SECTOR_SIZE - UFS_DIR_REC_LEN(1));
	ufs_set_de_namlen(sb, de, 2);
	strcpy (de->d_name, "..");

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