yaffs_fs.c

嵌入式linux yaffs文件系统源代码

				inode->i_op = &yaffs_file_inode_operations;
				inode->i_fop = &yaffs_file_operations;
				inode->i_mapping->a_ops = &yaffs_file_address_operations;
				break;
			case S_IFDIR:	// directory
				inode->i_op = &yaffs_dir_inode_operations;
				inode->i_fop = &yaffs_dir_operations;
				break;
			case S_IFLNK:	// symlink
				inode->i_op = &yaffs_symlink_inode_operations;
				break;
		}
		
		
		inode->u.generic_ip = obj;
		obj->myInode = inode;
		
	}
	else
	{
		T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_FileInode invalid parameters\n"));
	}

}

struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,yaffs_Object *obj)
{
	struct inode * inode;
	
	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_get_inode for object %d\n",obj->objectId));

	inode = iget(sb,obj->objectId);

	// NB Side effect: iget calls back to yaffs_read_inode().
	// iget also increments the inode's i_count
	
	return inode;
}

static ssize_t yaffs_file_read(struct file *f, char *buf, size_t n, loff_t *pos)
{
	yaffs_Object *obj;
	int nRead,ipos;
	struct inode *inode;
	yaffs_Device *dev;
	
	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_read\n"));

	obj  = yaffs_DentryToObject(f->f_dentry);
	
	dev = obj->myDev;
	
	yaffs_GrossLock(dev);
	
	inode = f->f_dentry->d_inode;
	
	if (*pos < inode->i_size) 
	{
			if (*pos + n > inode->i_size)
			{
				n = inode->i_size - *pos;
			}
	}
	else
	{
		n = 0;
	}
	
	nRead = yaffs_ReadDataFromFile(obj,buf,*pos,n);
	if(nRead > 0)
	{
		f->f_pos += nRead;
	}
	
	yaffs_GrossUnlock(dev);
	
	ipos = *pos;
	
	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_read read %d bytes, %d read at %d\n",n,nRead,ipos));
	return nRead;
	
}


static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, loff_t *pos)
{
	yaffs_Object *obj;
	int nWritten,ipos;
	struct inode *inode;
	yaffs_Device *dev;
	
	
	obj  = yaffs_DentryToObject(f->f_dentry);
	
	dev = obj->myDev;
	
	yaffs_GrossLock(dev);
	
	inode = f->f_dentry->d_inode;

	if(!S_ISBLK(inode->i_mode) && f->f_flags & O_APPEND)
	{
		ipos = inode->i_size;
	}
	else
	{
		ipos = *pos;
	}
	
	
	if(!obj)
	{
		T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_write: hey obj is null!\n"));
	}
	else
	{
		T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_write about to write writing %d bytes to object %d at %d\n",n,obj->objectId,ipos));
	}

	nWritten = yaffs_WriteDataToFile(obj,buf,ipos,n);

	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_write writing %d bytes, %d written at %d\n",n,nWritten,ipos));
	if(nWritten > 0)
	{
		ipos += nWritten;
		*pos = ipos;
		if(ipos > inode->i_size)
		{
			inode->i_size = ipos;
			inode->i_blocks = (ipos + inode->i_blksize - 1)/ inode->i_blksize;
			
			T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_write size updated to %d bytes, %d blocks\n",ipos,(int)(inode->i_blocks)));
		}
		
	}
	yaffs_GrossUnlock(dev);
	
	return nWritten != n ? -ENOSPC : nWritten;	
}


static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
{
	yaffs_Object *obj;
	yaffs_Device *dev;
	struct inode *inode = f->f_dentry->d_inode;
	unsigned long offset, curoffs;
	struct list_head *i;	
	yaffs_Object *l;
	
	char name[YAFFS_MAX_NAME_LENGTH	+1];
		
	obj =  yaffs_DentryToObject(f->f_dentry);
	dev = obj->myDev;
	
	yaffs_GrossLock(dev);
	
	offset = f->f_pos;
	
	T(YAFFS_TRACE_OS,("yaffs_readdir: starting at %d\n",(int)offset));
	
	if(offset == 0)
	{
        T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_readdir: entry . ino %d \n",(int)inode->i_ino));
		if(filldir(dirent,".",1,offset,inode->i_ino,DT_DIR) < 0)
		{
			goto out;
		}
		offset++;
		f->f_pos++;
	}
	if(offset == 1)
	{
		T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_readdir: entry .. ino %d \n",(int)f->f_dentry->d_parent->d_inode->i_ino));
		if(filldir(dirent,"..",2,offset,f->f_dentry->d_parent->d_inode->i_ino,DT_DIR) < 0)
		{
			goto out;
		}
		offset++;
		f->f_pos++;
	}
	
	curoffs = 1;
	
	list_for_each(i,&obj->variant.directoryVariant.children)
	{
		curoffs++;
		if(curoffs >= offset)
		{		
			l = list_entry(i, yaffs_Object,siblings);
			
			yaffs_GetObjectName(l,name,YAFFS_MAX_NAME_LENGTH+1); 
			T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_readdir: %s inode %d\n",name,yaffs_GetObjectInode(l)));
			
			if(filldir(dirent,
					   name,
					   strlen(name),
					   offset,
					   yaffs_GetObjectInode(l),
					   yaffs_GetObjectType(l))
					   < 0)
			{
				goto up_and_out;
			}
			
			offset++;
			f->f_pos++;	   
		}
	}

  up_and_out:
  out:
  
    yaffs_GrossUnlock(dev);
    
	return 0;
}


/*
 * File creation. Allocate an inode, and we're done..
 */
static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, int rdev)
{
	struct inode *inode;
	
	yaffs_Object *obj = NULL;
	yaffs_Device *dev;
	
	yaffs_Object *parent = yaffs_InodeToObject(dir);
	
	int error = -ENOSPC;

	if(parent)
	{
		T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: parent object %d type %d\n",
					 parent->objectId,parent->variantType));
	}
	else
	{
		T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: could not get parent object\n"));
		return -EPERM;
	}
	
	T(YAFFS_TRACE_OS,("yaffs_mknod: making oject for %s, mode %x dev %x\n",
					dentry->d_name.name, mode,rdev));

	dev = parent->myDev;
	
	yaffs_GrossLock(dev);

	switch (mode & S_IFMT) 
	{
		default:
			// Special (socket, fifo, device...)
			T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: making special\n"));
			obj = yaffs_MknodSpecial(parent,dentry->d_name.name,mode,current->uid, current->gid,rdev);
			break;
		case S_IFREG:	// file		
			T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: making file\n"));
			obj = yaffs_MknodFile(parent,dentry->d_name.name,mode,current->uid, current->gid);
			break;
		case S_IFDIR:	// directory
			T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: making directory\n"));
			obj = yaffs_MknodDirectory(parent,dentry->d_name.name,mode,current->uid, current->gid);
			break;
		case S_IFLNK:	// symlink
			T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: making file\n"));
			obj = NULL; // Do we ever get here?
			break;
	}
	
	if(obj)
	{
		inode = yaffs_get_inode(dir->i_sb, mode, rdev, obj);
		d_instantiate(dentry, inode);
		T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod created object %d count = %d\n",obj->objectId,atomic_read(&inode->i_count)));
		error = 0;
	}
	else
	{
		T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod failed making object\n"));
		error = -ENOMEM;
	}

	yaffs_GrossUnlock(dev);

	return error;
}

static int yaffs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
{
	int retVal;
	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mkdir\n"));
	retVal =  yaffs_mknod(dir, dentry, mode | S_IFDIR, 0);
#if 0
 // attempt to fix dir bug - didn't work
	if(!retVal)
	{
		dget(dentry);
	}
#endif
	return retVal;
}

static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode)
{
	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_create\n"));
	return yaffs_mknod(dir, dentry, mode | S_IFREG, 0);
}


static int yaffs_unlink(struct inode * dir, struct dentry *dentry)
{
	int retVal;
	
	yaffs_Device *dev;
	
	
	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_unlink %d:%s\n",(int)(dir->i_ino),dentry->d_name.name));
	
	dev = yaffs_InodeToObject(dir)->myDev;
	
	yaffs_GrossLock(dev);
	
	
	retVal = yaffs_Unlink(yaffs_InodeToObject(dir),dentry->d_name.name);
	
	
	yaffs_GrossUnlock(dev);
	
	if( retVal == YAFFS_OK)
	{
		dentry->d_inode->i_nlink--;
		mark_inode_dirty(dentry->d_inode);
		return 0;
	}
	else
	{
		return -ENOTEMPTY;
	}
}


/*
 * Create a link...
 */
static int yaffs_link(struct dentry *old_dentry, struct inode * dir, struct dentry * dentry)
{
	struct inode *inode = old_dentry->d_inode;
	yaffs_Object *obj = NULL;
	yaffs_Object *link=NULL;
	yaffs_Device *dev;
	
	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_link\n"));
	
	obj = yaffs_InodeToObject(inode);
	dev = obj->myDev;
	
	yaffs_GrossLock(dev);

	if (!S_ISDIR(inode->i_mode))	// Don't link directories
	{
		link = yaffs_Link(yaffs_InodeToObject(dir),dentry->d_name.name,obj);
	}
	

	if(link)
	{
		old_dentry->d_inode->i_nlink =  yaffs_GetObjectLinkCount(obj);
		d_instantiate(dentry, old_dentry->d_inode);
		atomic_inc(&old_dentry->d_inode->i_count);
		T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_link link count %d i_count %d\n",	
			old_dentry->d_inode->i_nlink,atomic_read(&old_dentry->d_inode->i_count)));
	
	}
	
	yaffs_GrossUnlock(dev);
	

	if(link)
	{
	
		return 0;
	}
	
	
	return -EPERM; 
}


static int yaffs_symlink(struct inode * dir, struct dentry *dentry, const char * symname)
{
	yaffs_Object *obj;
	yaffs_Device *dev;
	
	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_symlink\n"));
	
	dev = yaffs_InodeToObject(dir)->myDev;
	yaffs_GrossLock(dev);
	obj = yaffs_MknodSymLink(yaffs_InodeToObject(dir), dentry->d_name.name, 
							 S_IFLNK | S_IRWXUGO, current->uid, current->gid,
							 symname);
	yaffs_GrossUnlock(dev);

	if(obj)
	{

		struct inode* inode;
	
		inode = yaffs_get_inode(dir->i_sb, obj->st_mode, 0, obj);
		d_instantiate(dentry, inode);
		T(YAFFS_TRACE_OS,(KERN_DEBUG"symlink created OK\n"));
		return 0;
	}
	else
	{
		T(YAFFS_TRACE_OS,(KERN_DEBUG"symlink not created\n"));

	}
	
	return -ENOMEM;
}

static int yaffs_sync_object(struct file * file, struct dentry *dentry, int datasync)
{

	yaffs_Object *obj;
	yaffs_Device *dev;
	
	obj = yaffs_DentryToObject(dentry);

	dev = obj->myDev;
	
	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_sync_object\n"));
	yaffs_GrossLock(dev);
	yaffs_FlushFile(obj,1);
	yaffs_GrossUnlock(dev);
	return 0;
}

/*
 * The VFS layer already does all the dentry stuff for rename.
 *
 * NB: POSIX says you can rename an object over an old object of the same name
 */
static int yaffs_rename(struct inode * old_dir, struct dentry *old_dentry, struct inode * new_dir,struct dentry *new_dentry)
{
	yaffs_Device *dev;
	int retVal = YAFFS_FAIL;
	int removed = 0;
	yaffs_Object *target;
	
	dev = yaffs_InodeToObject(old_dir)->myDev;

	yaffs_GrossLock(dev);
	
	// Check if the target is an existing directory that is not empty.
	target = yaffs_FindObjectByName(yaffs_InodeToObject(new_dir),new_dentry->d_name.name);
	
	if(target &&
	   target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
	   !list_empty(&target->variant.directoryVariant.children))
	{
		retVal = YAFFS_FAIL;
	}
	else
	{
	   
		// Unlink the target if it exists
		removed = yaffs_Unlink(yaffs_InodeToObject(new_dir),new_dentry->d_name.name);

	
		retVal =  yaffs_RenameObject(yaffs_InodeToObject(old_dir),old_dentry->d_name.name,
									yaffs_InodeToObject(new_dir),new_dentry->d_name.name);
									
	}
	yaffs_GrossUnlock(dev);
	
	if(retVal == YAFFS_OK)
	{
		if(removed == YAFFS_OK)
		{
			new_dentry->d_inode->i_nlink--;
			mark_inode_dirty(new_dentry->d_inode);
		}
		
		return 0;
	}
	else
	{
		return -ENOTEMPTY;
	}