/* *  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/swap.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 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, loff_t pos, unsigned len){	struct address_space *mapping = page->mapping;	struct inode *dir = mapping->host;	int err = 0;	dir->i_version++;	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, 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){	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_write_begin(NULL, page->mapping, pos, len,				AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);	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);	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;	const unsigned chunk_mask = UFS_SB(sb)->s_uspi->s_dirblksize - 1;	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 & 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;	/* 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, __func__,		   "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_mapping_page(mapping, n, NULL);	if (!IS_ERR(page)) {		kmap(page);		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 unsignedufs_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_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 (de->d_reclen == 0) {					ufs_error(dir->i_sb, __func__,						  "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;	ui->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);	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 = ufs_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.	 */