/* * YAFFS: Yet another FFS. A NAND-flash specific file system. * yaffs_fs.c * * Copyright (C) 2002 Aleph One Ltd. *   for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles@aleph1.co.uk> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This is the file system front-end to YAFFS that hooks it up to * the VFS. * * Special notes:  * >> sb->u.generic_sbp points to the yaffs_Device associated with this superblock * >> inode->u.generic_ip points to the associated yaffs_Object. * * * Acknowledgements: * * Luc van OostenRyck for numerous patches. * * Nick Bane for numerous patches. * * Andras Toth for mknod rdev issue. * * Some code bodily lifted from JFFS2. */const char *yaffs_fs_c_version = "$Id: yaffs_fs.c,v 1.26 2003/05/20 23:20:53 charles Exp $";extern const char *yaffs_guts_c_version;#include <linux/config.h>#include <linux/kernel.h>#include <linux/module.h>#include <linux/version.h>#include <linux/slab.h>#include <linux/init.h>#include <linux/list.h>#include <linux/fs.h>#include <linux/proc_fs.h>#include <linux/pagemap.h>#include <linux/mtd/mtd.h>#include <linux/interrupt.h>#include <linux/string.h>#include <linux/locks.h>#include <asm/uaccess.h>#include "yportenv.h"#include "yaffs_guts.h"unsigned yaffs_traceMask = YAFFS_TRACE_ALWAYS | YAFFS_TRACE_BAD_BLOCKS;#ifdef CONFIG_YAFFS_RAM_ENABLED#include "yaffs_nandemul.h" // 2 MB of RAM for emulation#define YAFFS_RAM_EMULATION_SIZE  0x200000#endif //CONFIG_YAFFS_RAM_ENABLED#ifdef CONFIG_YAFFS_MTD_ENABLED#include <linux/mtd/mtd.h>#include "yaffs_mtdif.h"#endif //CONFIG_YAFFS_MTD_ENABLED//#define T(x) printk x#define yaffs_InodeToObject(iptr) ((yaffs_Object *)((iptr)->u.generic_ip))#define yaffs_DentryToObject(dptr) yaffs_InodeToObject((dptr)->d_inode)#define yaffs_SuperToDevice(sb)	((yaffs_Device *)sb->u.generic_sbp)static void yaffs_put_super(struct super_block *sb);static ssize_t yaffs_file_read(struct file *f, char *buf, size_t n, loff_t *pos);static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, loff_t *pos);static int yaffs_file_flush(struct file* file);static int yaffs_sync_object(struct file * file, struct dentry *dentry, int datasync);static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir);static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode);static struct dentry * yaffs_lookup(struct inode *dir, struct dentry *dentry);static int yaffs_link(struct dentry *old_dentry, struct inode * dir, struct dentry * dentry);static int yaffs_unlink(struct inode * dir, struct dentry *dentry);static int yaffs_symlink(struct inode * dir, struct dentry *dentry, const char * symname);static int yaffs_mkdir(struct inode * dir, struct dentry * dentry, int mode);static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, int dev);static int yaffs_rename(struct inode * old_dir, struct dentry *old_dentry, struct inode * new_dir,struct dentry *new_dentry);static int yaffs_setattr(struct dentry *dentry, struct iattr *attr);static int yaffs_statfs(struct super_block *sb, struct statfs *buf);static void yaffs_read_inode (struct inode *inode);static struct super_block *yaffs_read_super(struct super_block * sb, void * data, int silent);static void yaffs_put_inode (struct inode *inode);static void yaffs_delete_inode(struct inode *);static void yaffs_clear_inode(struct inode *);static int yaffs_readpage(struct file *file, struct page * page);static int yaffs_prepare_write(struct file *f, struct page *pg, unsigned offset, unsigned to);static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, unsigned to);static int yaffs_readlink(struct dentry *dentry, char *buffer, int buflen);static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);static struct address_space_operations yaffs_file_address_operations = {	readpage:		yaffs_readpage,	prepare_write:	yaffs_prepare_write,	commit_write:	yaffs_commit_write};static struct file_operations yaffs_file_operations = {#ifdef CONFIG_YAFFS_USE_GENERIC_RW	read:		generic_file_read,	write:		generic_file_write,#else	read:		yaffs_file_read,	write:		yaffs_file_write,#endif	mmap:		generic_file_mmap,	flush:		yaffs_file_flush,	fsync:		yaffs_sync_object,};static struct inode_operations yaffs_file_inode_operations = {	setattr:	yaffs_setattr,};struct inode_operations yaffs_symlink_inode_operations ={		readlink:	yaffs_readlink,	follow_link:	yaffs_follow_link,	setattr:	yaffs_setattr};static struct inode_operations yaffs_dir_inode_operations = {	create:		yaffs_create,	lookup:		yaffs_lookup,	link:		yaffs_link,	unlink:		yaffs_unlink,		symlink:	yaffs_symlink,	mkdir:		yaffs_mkdir,	rmdir:		yaffs_unlink,	mknod:		yaffs_mknod,	rename:		yaffs_rename,	setattr:	yaffs_setattr,};static struct file_operations yaffs_dir_operations = {	read:		generic_read_dir,	readdir:	yaffs_readdir,	fsync:		yaffs_sync_object,};static struct super_operations yaffs_super_ops = {	statfs:			yaffs_statfs,	read_inode:		yaffs_read_inode,	put_inode:		yaffs_put_inode,	put_super:		yaffs_put_super,//	remount_fs:	delete_inode:		yaffs_delete_inode,	clear_inode:		yaffs_clear_inode,};static void yaffs_GrossLock(yaffs_Device *dev){	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs locking\n"));	down(&dev->grossLock);}static void yaffs_GrossUnlock(yaffs_Device *dev){	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs unlocking\n"));	up(&dev->grossLock);}static int yaffs_readlink(struct dentry *dentry, char *buffer, int buflen){	unsigned char *alias;	int ret;	yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev;	yaffs_GrossLock(dev);		alias = yaffs_GetSymlinkAlias(yaffs_DentryToObject(dentry));		yaffs_GrossUnlock(dev);		if(!alias)		return -ENOMEM;	ret = vfs_readlink(dentry, buffer, buflen, alias);	kfree(alias);	return ret;}static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd){	unsigned char *alias;	int ret;	yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev;	yaffs_GrossLock(dev);	alias = yaffs_GetSymlinkAlias(yaffs_DentryToObject(dentry));		yaffs_GrossUnlock(dev);		if(!alias)		return -ENOMEM;	ret = vfs_follow_link(nd,alias);	kfree(alias);	return ret;}struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,yaffs_Object *obj);/* * Lookup is used to find objects in the fs */static struct dentry * yaffs_lookup(struct inode *dir, struct dentry *dentry){	yaffs_Object *obj;	struct inode *inode;		yaffs_Device *dev = yaffs_InodeToObject(dir)->myDev;	yaffs_GrossLock(dev);		T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_lookup for %d:%s\n",yaffs_InodeToObject(dir)->objectId,dentry->d_name.name));		obj = yaffs_FindObjectByName(yaffs_InodeToObject(dir),dentry->d_name.name);		obj = yaffs_GetEquivalentObject(obj); // in case it was a hardlink			if(obj)	{		T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_lookup found %d\n",obj->objectId));				inode = yaffs_get_inode(dir->i_sb, obj->st_mode,0,obj);				if(inode)		{			T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_loookup dentry \n"));			//dget(dentry); // try to solve directory bug			d_add(dentry,inode);						yaffs_GrossUnlock(dev);			// return dentry;			return NULL;		}	}	else	{		T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_lookup not found\n"));			}	yaffs_GrossUnlock(dev);		return NULL;	//	return (ERR_PTR(-EIO));	}// For now put inode is just for debugging// Put inode is called when the inode **structure** is put.static void yaffs_put_inode(struct inode *inode){	T(YAFFS_TRACE_OS,("yaffs_put_inode: ino %d, count %d\n",(int)inode->i_ino, atomic_read(&inode->i_count)));	}// clear is called to tell the fs to release any per-inode data it holdsstatic void yaffs_clear_inode(struct inode *inode){	yaffs_Object *obj = yaffs_InodeToObject(inode);		T(YAFFS_TRACE_OS,("yaffs_clear_inode: ino %d, count %d %s\n",(int)inode->i_ino, atomic_read(&inode->i_count),		obj ? "object exists" : "null object"));		if(obj)	{		obj->myInode = NULL;		inode->u.generic_ip = NULL;		}		}// delete is called when the link count is zero and the inode// is put (ie. nobody wants to know about it anymore, time to// delete the file).// NB Must call clear_inode()static void yaffs_delete_inode(struct inode *inode){	yaffs_Object *obj = yaffs_InodeToObject(inode);	yaffs_Device *dev;	T(YAFFS_TRACE_OS,("yaffs_delete_inode: ino %d, count %d %s\n",(int)inode->i_ino, atomic_read(&inode->i_count),		obj ? "object exists" : "null object"));		if(obj)	{	 	dev = obj->myDev;		yaffs_GrossLock(dev);		yaffs_DeleteFile(obj);		yaffs_GrossUnlock(dev);	}	clear_inode(inode);}static int yaffs_file_flush(struct file* file){	yaffs_Object *obj = yaffs_DentryToObject(file->f_dentry);		yaffs_Device *dev = obj->myDev;		T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_flush object %d (%s)\n",obj->objectId,				obj->dirty ? "dirty" : "clean"));	yaffs_GrossLock(dev);	    yaffs_FlushFile(obj,1);	yaffs_GrossUnlock(dev);    return 0;}static int yaffs_readpage_nolock(struct file *f, struct page * pg){	// Lifted from jffs2		yaffs_Object *obj;	unsigned char *pg_buf;		int ret;		yaffs_Device *dev;		T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_readpage at %08x, size %08x\n", 	              (unsigned)(pg->index << PAGE_CACHE_SHIFT), (unsigned)PAGE_CACHE_SIZE));	obj  = yaffs_DentryToObject(f->f_dentry);	dev = obj->myDev;			if (!PageLocked(pg))                PAGE_BUG(pg);	pg_buf = kmap(pg);	/* FIXME: Can kmap fail? */	yaffs_GrossLock(dev);		ret = yaffs_ReadDataFromFile(obj, pg_buf, pg->index << PAGE_CACHE_SHIFT, PAGE_CACHE_SIZE);	yaffs_GrossUnlock(dev);		if(ret >= 0) ret = 0;	if (ret) {		ClearPageUptodate(pg);		SetPageError(pg);	} else {		SetPageUptodate(pg);		ClearPageError(pg);	}	flush_dcache_page(pg);	kunmap(pg);	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_readpage done\n"));	return ret;}static int yaffs_readpage_unlock(struct file *f, struct page *pg){	int ret = yaffs_readpage_nolock(f,pg);	UnlockPage(pg);	return ret;}static int yaffs_readpage(struct file *f, struct page * pg){	return yaffs_readpage_unlock(f,pg);}static int yaffs_prepare_write(struct file *f, struct page *pg, unsigned offset, unsigned to){	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_prepair_write\n"));	if(!Page_Uptodate(pg) && (offset || to < PAGE_CACHE_SIZE))		return  yaffs_readpage_nolock(f,pg);    	return 0;	}static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, unsigned to){	void *addr = page_address(pg) + offset;	loff_t pos = (((loff_t)pg->index) << PAGE_CACHE_SHIFT) + offset;	int nBytes = to - offset;	int nWritten;		unsigned spos = pos;	unsigned saddr = (unsigned)addr;	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_commit_write addr %x pos %x nBytes %d\n",saddr,spos,nBytes));		nWritten = yaffs_file_write(f,addr, nBytes, &pos);		if(nWritten != nBytes)	{		T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_commit_write not same size nWritten %d  nBytes %d\n",nWritten,nBytes));		SetPageError(pg);		ClearPageUptodate(pg);	}	else	{		SetPageUptodate(pg);	}	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_commit_write returning %d\n",nWritten));		return nWritten;}static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object *obj){	if (inode && obj) 	{		inode->i_ino = obj->objectId;		inode->i_mode = obj->st_mode;		inode->i_uid = obj->st_uid;		inode->i_gid = obj->st_gid;		inode->i_blksize = inode->i_sb->s_blocksize;		inode->i_blocks = 0;		inode->i_rdev = obj->st_rdev;;		inode->i_atime = obj->st_atime;		inode->i_mtime = obj->st_mtime;		inode->i_ctime = obj->st_ctime;		inode->i_size = yaffs_GetObjectFileLength(obj);		inode->i_nlink = yaffs_GetObjectLinkCount(obj);				T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_FillInode mode %x uid %d gid %d size %d count %d\n",				inode->i_mode, inode->i_uid, inode->i_gid, (int)inode->i_size, atomic_read(&inode->i_count)));				switch (obj->st_mode & S_IFMT) 		{			default: // fifo, device or socket				init_special_inode(inode, obj->st_mode, obj->st_rdev);				break;			case S_IFREG:	// file