[net-next-2.6.git] / fs / jffs2 / fs.c

/*
 * JFFS2 -- Journalling Flash File System, Version 2.
 *
 * Copyright (C) 2001-2003 Red Hat, Inc.
 *
 * Created by David Woodhouse <dwmw2@infradead.org>
 *
 * For licensing information, see the file 'LICENCE' in this directory.
 *
 * $Id: fs.c,v 1.60 2005/07/22 10:32:08 dedekind Exp $
 *
 */

#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/fs.h>
#include <linux/list.h>
#include <linux/mtd/mtd.h>
#include <linux/pagemap.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/vfs.h>
#include <linux/crc32.h>
#include "nodelist.h"

static int jffs2_flash_setup(struct jffs2_sb_info *c);

static int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
{
	struct jffs2_full_dnode *old_metadata, *new_metadata;
	struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
	struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
	struct jffs2_raw_inode *ri;
	unsigned short dev;
	unsigned char *mdata = NULL;
	int mdatalen = 0;
	unsigned int ivalid;
	uint32_t phys_ofs, alloclen;
	int ret;
	D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
	ret = inode_change_ok(inode, iattr);
	if (ret) 
		return ret;

	/* Special cases - we don't want more than one data node
	   for these types on the medium at any time. So setattr
	   must read the original data associated with the node
	   (i.e. the device numbers or the target name) and write
	   it out again with the appropriate data attached */
	if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
		/* For these, we don't actually need to read the old node */
		dev = old_encode_dev(inode->i_rdev);
		mdata = (char *)&dev;
		mdatalen = sizeof(dev);
		D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
	} else if (S_ISLNK(inode->i_mode)) {
		mdatalen = f->metadata->size;
		mdata = kmalloc(f->metadata->size, GFP_USER);
		if (!mdata)
			return -ENOMEM;
		ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
		if (ret) {
			kfree(mdata);
			return ret;
		}
		D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
	}

	ri = jffs2_alloc_raw_inode();
	if (!ri) {
		if (S_ISLNK(inode->i_mode))
			kfree(mdata);
		return -ENOMEM;
	}
		
	ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &phys_ofs, &alloclen, ALLOC_NORMAL);
	if (ret) {
		jffs2_free_raw_inode(ri);
		if (S_ISLNK(inode->i_mode & S_IFMT))
			 kfree(mdata);
		return ret;
	}
	down(&f->sem);
	ivalid = iattr->ia_valid;
	
	ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
	ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
	ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
	ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));

	ri->ino = cpu_to_je32(inode->i_ino);
	ri->version = cpu_to_je32(++f->highest_version);

	ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid);
	ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid);

	if (ivalid & ATTR_MODE)
		if (iattr->ia_mode & S_ISGID &&
		    !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))
			ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);
		else 
			ri->mode = cpu_to_jemode(iattr->ia_mode);
	else
		ri->mode = cpu_to_jemode(inode->i_mode);


	ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
	ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
	ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
	ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));

	ri->offset = cpu_to_je32(0);
	ri->csize = ri->dsize = cpu_to_je32(mdatalen);
	ri->compr = JFFS2_COMPR_NONE;
	if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
		/* It's an extension. Make it a hole node */
		ri->compr = JFFS2_COMPR_ZERO;
		ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
		ri->offset = cpu_to_je32(inode->i_size);
	}
	ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
	if (mdatalen)
		ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
	else
		ri->data_crc = cpu_to_je32(0);

	new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, phys_ofs, ALLOC_NORMAL);
	if (S_ISLNK(inode->i_mode))
		kfree(mdata);
	
	if (IS_ERR(new_metadata)) {
		jffs2_complete_reservation(c);
		jffs2_free_raw_inode(ri);
		up(&f->sem);
		return PTR_ERR(new_metadata);
	}
	/* It worked. Update the inode */
	inode->i_atime = ITIME(je32_to_cpu(ri->atime));
	inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
	inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
	inode->i_mode = jemode_to_cpu(ri->mode);
	inode->i_uid = je16_to_cpu(ri->uid);
	inode->i_gid = je16_to_cpu(ri->gid);


	old_metadata = f->metadata;

	if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
		jffs2_truncate_fraglist (c, &f->fragtree, iattr->ia_size);

	if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
		jffs2_add_full_dnode_to_inode(c, f, new_metadata);
		inode->i_size = iattr->ia_size;
		f->metadata = NULL;
	} else {
		f->metadata = new_metadata;
	}
	if (old_metadata) {
		jffs2_mark_node_obsolete(c, old_metadata->raw);
		jffs2_free_full_dnode(old_metadata);
	}
	jffs2_free_raw_inode(ri);

	up(&f->sem);
	jffs2_complete_reservation(c);

	/* We have to do the vmtruncate() without f->sem held, since
	   some pages may be locked and waiting for it in readpage(). 
	   We are protected from a simultaneous write() extending i_size
	   back past iattr->ia_size, because do_truncate() holds the
	   generic inode semaphore. */
	if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
		vmtruncate(inode, iattr->ia_size);

	return 0;
}

int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
{
	return jffs2_do_setattr(dentry->d_inode, iattr);
}

int jffs2_statfs(struct super_block *sb, struct kstatfs *buf)
{
	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
	unsigned long avail;

	buf->f_type = JFFS2_SUPER_MAGIC;
	buf->f_bsize = 1 << PAGE_SHIFT;
	buf->f_blocks = c->flash_size >> PAGE_SHIFT;
	buf->f_files = 0;
	buf->f_ffree = 0;
	buf->f_namelen = JFFS2_MAX_NAME_LEN;

	spin_lock(&c->erase_completion_lock);
	avail = c->dirty_size + c->free_size;
	if (avail > c->sector_size * c->resv_blocks_write)
		avail -= c->sector_size * c->resv_blocks_write;
	else
		avail = 0;
	spin_unlock(&c->erase_completion_lock);

	buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;

	return 0;
}


void jffs2_clear_inode (struct inode *inode)
{
	/* We can forget about this inode for now - drop all 
	 *  the nodelists associated with it, etc.
	 */
	struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
	struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
	
	D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));

	jffs2_do_clear_inode(c, f);
}

void jffs2_read_inode (struct inode *inode)
{
	struct jffs2_inode_info *f;
	struct jffs2_sb_info *c;
	struct jffs2_raw_inode latest_node;
	int ret;

	D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));

	f = JFFS2_INODE_INFO(inode);
	c = JFFS2_SB_INFO(inode->i_sb);

	jffs2_init_inode_info(f);
	
	ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);

	if (ret) {
		make_bad_inode(inode);
		up(&f->sem);
		return;
	}
	inode->i_mode = jemode_to_cpu(latest_node.mode);
	inode->i_uid = je16_to_cpu(latest_node.uid);
	inode->i_gid = je16_to_cpu(latest_node.gid);
	inode->i_size = je32_to_cpu(latest_node.isize);
	inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
	inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
	inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));

	inode->i_nlink = f->inocache->nlink;

	inode->i_blksize = PAGE_SIZE;
	inode->i_blocks = (inode->i_size + 511) >> 9;
	
	switch (inode->i_mode & S_IFMT) {
		jint16_t rdev;

	case S_IFLNK:
		inode->i_op = &jffs2_symlink_inode_operations;
		break;
		
	case S_IFDIR:
	{
		struct jffs2_full_dirent *fd;

		for (fd=f->dents; fd; fd = fd->next) {
			if (fd->type == DT_DIR && fd->ino)
				inode->i_nlink++;
		}
		/* and '..' */
		inode->i_nlink++;
		/* Root dir gets i_nlink 3 for some reason */
		if (inode->i_ino == 1)
			inode->i_nlink++;

		inode->i_op = &jffs2_dir_inode_operations;
		inode->i_fop = &jffs2_dir_operations;
		break;
	}
	case S_IFREG:
		inode->i_op = &jffs2_file_inode_operations;
		inode->i_fop = &jffs2_file_operations;
		inode->i_mapping->a_ops = &jffs2_file_address_operations;
		inode->i_mapping->nrpages = 0;
		break;

	case S_IFBLK:
	case S_IFCHR:
		/* Read the device numbers from the media */
		D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
		if (jffs2_read_dnode(c, f, f->metadata, (char *)&rdev, 0, sizeof(rdev)) < 0) {
			/* Eep */
			printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
			up(&f->sem);
			jffs2_do_clear_inode(c, f);
			make_bad_inode(inode);
			return;
		}			

	case S_IFSOCK:
	case S_IFIFO:
		inode->i_op = &jffs2_file_inode_operations;
		init_special_inode(inode, inode->i_mode,
				   old_decode_dev((je16_to_cpu(rdev))));
		break;

	default:
		printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
	}

	up(&f->sem);

	D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
}

void jffs2_dirty_inode(struct inode *inode)
{
	struct iattr iattr;

	if (!(inode->i_state & I_DIRTY_DATASYNC)) {
		D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
		return;
	}

	D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));

	iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
	iattr.ia_mode = inode->i_mode;
	iattr.ia_uid = inode->i_uid;
	iattr.ia_gid = inode->i_gid;
	iattr.ia_atime = inode->i_atime;
	iattr.ia_mtime = inode->i_mtime;
	iattr.ia_ctime = inode->i_ctime;

	jffs2_do_setattr(inode, &iattr);
}

int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
{
	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);

	if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
		return -EROFS;

	/* We stop if it was running, then restart if it needs to.
	   This also catches the case where it was stopped and this
	   is just a remount to restart it.
	   Flush the writebuffer, if neccecary, else we loose it */
	if (!(sb->s_flags & MS_RDONLY)) {
		jffs2_stop_garbage_collect_thread(c);
		down(&c->alloc_sem);
		jffs2_flush_wbuf_pad(c);
		up(&c->alloc_sem);
	}	

	if (!(*flags & MS_RDONLY))
		jffs2_start_garbage_collect_thread(c);
	
	*flags |= MS_NOATIME;

	return 0;
}

void jffs2_write_super (struct super_block *sb)
{
	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
	sb->s_dirt = 0;

	if (sb->s_flags & MS_RDONLY)
		return;

	D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
	jffs2_garbage_collect_trigger(c);
	jffs2_erase_pending_blocks(c, 0);
	jffs2_flush_wbuf_gc(c, 0);
}


/* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
   fill in the raw_inode while you're at it. */
struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
{
	struct inode *inode;
	struct super_block *sb = dir_i->i_sb;
	struct jffs2_sb_info *c;
	struct jffs2_inode_info *f;
	int ret;

	D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));

	c = JFFS2_SB_INFO(sb);
	
	inode = new_inode(sb);
	
	if (!inode)
		return ERR_PTR(-ENOMEM);

	f = JFFS2_INODE_INFO(inode);
	jffs2_init_inode_info(f);

	memset(ri, 0, sizeof(*ri));
	/* Set OS-specific defaults for new inodes */
	ri->uid = cpu_to_je16(current->fsuid);

	if (dir_i->i_mode & S_ISGID) {
		ri->gid = cpu_to_je16(dir_i->i_gid);
		if (S_ISDIR(mode))
			mode |= S_ISGID;
	} else {
		ri->gid = cpu_to_je16(current->fsgid);
	}
	ri->mode =  cpu_to_jemode(mode);
	ret = jffs2_do_new_inode (c, f, mode, ri);
	if (ret) {
		make_bad_inode(inode);
		iput(inode);
		return ERR_PTR(ret);
	}
	inode->i_nlink = 1;
	inode->i_ino = je32_to_cpu(ri->ino);
	inode->i_mode = jemode_to_cpu(ri->mode);
	inode->i_gid = je16_to_cpu(ri->gid);
	inode->i_uid = je16_to_cpu(ri->uid);
	inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
	ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));

	inode->i_blksize = PAGE_SIZE;
	inode->i_blocks = 0;
	inode->i_size = 0;

	insert_inode_hash(inode);

	return inode;
}


int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
{
	struct jffs2_sb_info *c;
	struct inode *root_i;
	int ret;
	size_t blocks;

	c = JFFS2_SB_INFO(sb);

#ifndef CONFIG_JFFS2_FS_WRITEBUFFER
	if (c->mtd->type == MTD_NANDFLASH) {
		printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
		return -EINVAL;
	}
	if (c->mtd->type == MTD_DATAFLASH) {
		printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
		return -EINVAL;
	}
#endif

	c->flash_size = c->mtd->size;

	/* 
	 * Check, if we have to concatenate physical blocks to larger virtual blocks
	 * to reduce the memorysize for c->blocks. (kmalloc allows max. 128K allocation)
	 */
	c->sector_size = c->mtd->erasesize; 
	blocks = c->flash_size / c->sector_size;
	if (!(c->mtd->flags & MTD_NO_VIRTBLOCKS)) {
		while ((blocks * sizeof (struct jffs2_eraseblock)) > (128 * 1024)) {
			blocks >>= 1;
			c->sector_size <<= 1;
		}	
	}

	/*
	 * Size alignment check
	 */
	if ((c->sector_size * blocks) != c->flash_size) {
		c->flash_size = c->sector_size * blocks;		
		printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
			c->flash_size / 1024);
	}

	if (c->sector_size != c->mtd->erasesize)
		printk(KERN_INFO "jffs2: Erase block size too small (%dKiB). Using virtual blocks size (%dKiB) instead\n", 
			c->mtd->erasesize / 1024, c->sector_size / 1024);

	if (c->flash_size < 5*c->sector_size) {
		printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
		return -EINVAL;
	}

	c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
	/* Joern -- stick alignment for weird 8-byte-page flash here */

	/* NAND (or other bizarre) flash... do setup accordingly */
	ret = jffs2_flash_setup(c);
	if (ret)
		return ret;

	c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
	if (!c->inocache_list) {
		ret = -ENOMEM;
		goto out_wbuf;
	}
	memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));

	if ((ret = jffs2_do_mount_fs(c)))
		goto out_inohash;

	ret = -EINVAL;

	D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
	root_i = iget(sb, 1);
	if (is_bad_inode(root_i)) {
		D1(printk(KERN_WARNING "get root inode failed\n"));
		goto out_root_i;
	}

	D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
	sb->s_root = d_alloc_root(root_i);
	if (!sb->s_root)
		goto out_root_i;

	sb->s_maxbytes = 0xFFFFFFFF;
	sb->s_blocksize = PAGE_CACHE_SIZE;
	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
	sb->s_magic = JFFS2_SUPER_MAGIC;
	if (!(sb->s_flags & MS_RDONLY))
		jffs2_start_garbage_collect_thread(c);
	return 0;

 out_root_i:
	iput(root_i);
	jffs2_free_ino_caches(c);
	jffs2_free_raw_node_refs(c);
	if (c->mtd->flags & MTD_NO_VIRTBLOCKS)
		vfree(c->blocks);
	else
		kfree(c->blocks);
 out_inohash:
	kfree(c->inocache_list);
 out_wbuf:
	jffs2_flash_cleanup(c);

	return ret;
}

void jffs2_gc_release_inode(struct jffs2_sb_info *c,
				   struct jffs2_inode_info *f)
{
	iput(OFNI_EDONI_2SFFJ(f));
}

struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
						     int inum, int nlink)
{
	struct inode *inode;
	struct jffs2_inode_cache *ic;
	if (!nlink) {
		/* The inode has zero nlink but its nodes weren't yet marked
		   obsolete. This has to be because we're still waiting for 
		   the final (close() and) iput() to happen.

		   There's a possibility that the final iput() could have 
		   happened while we were contemplating. In order to ensure
		   that we don't cause a new read_inode() (which would fail)
		   for the inode in question, we use ilookup() in this case
		   instead of iget().

		   The nlink can't _become_ zero at this point because we're 
		   holding the alloc_sem, and jffs2_do_unlink() would also
		   need that while decrementing nlink on any inode.
		*/
		inode = ilookup(OFNI_BS_2SFFJ(c), inum);
		if (!inode) {
			D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
				  inum));

			spin_lock(&c->inocache_lock);
			ic = jffs2_get_ino_cache(c, inum);
			if (!ic) {
				D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
				spin_unlock(&c->inocache_lock);
				return NULL;
			}
			if (ic->state != INO_STATE_CHECKEDABSENT) {
				/* Wait for progress. Don't just loop */
				D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
					  ic->ino, ic->state));
				sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
			} else {
				spin_unlock(&c->inocache_lock);
			}

			return NULL;
		}
	} else {
		/* Inode has links to it still; they're not going away because
		   jffs2_do_unlink() would need the alloc_sem and we have it.
		   Just iget() it, and if read_inode() is necessary that's OK.
		*/
		inode = iget(OFNI_BS_2SFFJ(c), inum);
		if (!inode)
			return ERR_PTR(-ENOMEM);
	}
	if (is_bad_inode(inode)) {
		printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
		       inum, nlink);
		/* NB. This will happen again. We need to do something appropriate here. */
		iput(inode);
		return ERR_PTR(-EIO);
	}

	return JFFS2_INODE_INFO(inode);
}

unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c, 
				   struct jffs2_inode_info *f, 
				   unsigned long offset,
				   unsigned long *priv)
{
	struct inode *inode = OFNI_EDONI_2SFFJ(f);
	struct page *pg;

	pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT, 
			     (void *)jffs2_do_readpage_unlock, inode);
	if (IS_ERR(pg))
		return (void *)pg;
	
	*priv = (unsigned long)pg;
	return kmap(pg);
}

void jffs2_gc_release_page(struct jffs2_sb_info *c,
			   unsigned char *ptr,
			   unsigned long *priv)
{
	struct page *pg = (void *)*priv;

	kunmap(pg);
	page_cache_release(pg);
}

static int jffs2_flash_setup(struct jffs2_sb_info *c) {
	int ret = 0;
	
	if (jffs2_cleanmarker_oob(c)) {
		/* NAND flash... do setup accordingly */
		ret = jffs2_nand_flash_setup(c);
		if (ret)
			return ret;
	}

	/* add setups for other bizarre flashes here... */
	if (jffs2_nor_ecc(c)) {
		ret = jffs2_nor_ecc_flash_setup(c);
		if (ret)
			return ret;
	}
	
	/* and Dataflash */
	if (jffs2_dataflash(c)) {
		ret = jffs2_dataflash_setup(c);
		if (ret)
			return ret;
	}
	
	return ret;
}

void jffs2_flash_cleanup(struct jffs2_sb_info *c) {

	if (jffs2_cleanmarker_oob(c)) {
		jffs2_nand_flash_cleanup(c);
	}

	/* add cleanups for other bizarre flashes here... */
	if (jffs2_nor_ecc(c)) {
		jffs2_nor_ecc_flash_cleanup(c);
	}
	
	/* and DataFlash */
	if (jffs2_dataflash(c)) {
		jffs2_dataflash_cleanup(c);
	}
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* JFFS2 -- Journalling Flash File System, Version 2.
	3	*
	4	* Copyright (C) 2001-2003 Red Hat, Inc.
	5	*
	6	* Created by David Woodhouse <dwmw2@infradead.org>
	7	*
	8	* For licensing information, see the file 'LICENCE' in this directory.
	9	*
e0c8e42f	10	* $Id: fs.c,v 1.60 2005/07/22 10:32:08 dedekind Exp $
1da177e4 LT	11	*
	12	*/
	13
1da177e4 LT	14	#include <linux/config.h>
	15	#include <linux/kernel.h>
	16	#include <linux/sched.h>
	17	#include <linux/fs.h>
	18	#include <linux/list.h>
	19	#include <linux/mtd/mtd.h>
	20	#include <linux/pagemap.h>
	21	#include <linux/slab.h>
	22	#include <linux/vmalloc.h>
	23	#include <linux/vfs.h>
	24	#include <linux/crc32.h>
	25	#include "nodelist.h"
	26
	27	static int jffs2_flash_setup(struct jffs2_sb_info *c);
	28
	29	static int jffs2_do_setattr (struct inode inode, struct iattr iattr)
	30	{
	31	struct jffs2_full_dnode old_metadata, new_metadata;
	32	struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
	33	struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
	34	struct jffs2_raw_inode *ri;
	35	unsigned short dev;
	36	unsigned char *mdata = NULL;
	37	int mdatalen = 0;
	38	unsigned int ivalid;
	39	uint32_t phys_ofs, alloclen;
	40	int ret;
	41	D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
	42	ret = inode_change_ok(inode, iattr);
	43	if (ret)
	44	return ret;
	45
	46	/* Special cases - we don't want more than one data node
	47	for these types on the medium at any time. So setattr
	48	must read the original data associated with the node
	49	(i.e. the device numbers or the target name) and write
	50	it out again with the appropriate data attached */
	51	if (S_ISBLK(inode->i_mode) \|\| S_ISCHR(inode->i_mode)) {
	52	/* For these, we don't actually need to read the old node */
	53	dev = old_encode_dev(inode->i_rdev);
	54	mdata = (char *)&dev;
	55	mdatalen = sizeof(dev);
	56	D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
	57	} else if (S_ISLNK(inode->i_mode)) {
	58	mdatalen = f->metadata->size;
	59	mdata = kmalloc(f->metadata->size, GFP_USER);
	60	if (!mdata)
	61	return -ENOMEM;
	62	ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
	63	if (ret) {
	64	kfree(mdata);
	65	return ret;
	66	}
	67	D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
	68	}
	69
	70	ri = jffs2_alloc_raw_inode();
	71	if (!ri) {
	72	if (S_ISLNK(inode->i_mode))
	73	kfree(mdata);
	74	return -ENOMEM;
	75	}
	76
	77	ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &phys_ofs, &alloclen, ALLOC_NORMAL);
78	if (ret) {
79	jffs2_free_raw_inode(ri);
80	if (S_ISLNK(inode->i_mode & S_IFMT))
81	kfree(mdata);
82	return ret;
83	}
84	down(&f->sem);
85	ivalid = iattr->ia_valid;
86
87	ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
88	ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
89	ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
90	ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
91
92	ri->ino = cpu_to_je32(inode->i_ino);
93	ri->version = cpu_to_je32(++f->highest_version);
94
95	ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid);
96	ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid);
97
98	if (ivalid & ATTR_MODE)
99	if (iattr->ia_mode & S_ISGID &&
100	!in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))
101	ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);
102	else
103	ri->mode = cpu_to_jemode(iattr->ia_mode);
104	else
105	ri->mode = cpu_to_jemode(inode->i_mode);
106
107
108	ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
109	ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
110	ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
111	ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
112
113	ri->offset = cpu_to_je32(0);
114	ri->csize = ri->dsize = cpu_to_je32(mdatalen);
115	ri->compr = JFFS2_COMPR_NONE;
116	if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
117	/* It's an extension. Make it a hole node */
118	ri->compr = JFFS2_COMPR_ZERO;
119	ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
120	ri->offset = cpu_to_je32(inode->i_size);
121	}
122	ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
123	if (mdatalen)
124	ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
125	else
126	ri->data_crc = cpu_to_je32(0);
127
128	new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, phys_ofs, ALLOC_NORMAL);
129	if (S_ISLNK(inode->i_mode))
130	kfree(mdata);
131
132	if (IS_ERR(new_metadata)) {
133	jffs2_complete_reservation(c);
134	jffs2_free_raw_inode(ri);
135	up(&f->sem);
136	return PTR_ERR(new_metadata);
137	}
138	/* It worked. Update the inode */
139	inode->i_atime = ITIME(je32_to_cpu(ri->atime));
140	inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
141	inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
142	inode->i_mode = jemode_to_cpu(ri->mode);
143	inode->i_uid = je16_to_cpu(ri->uid);
144	inode->i_gid = je16_to_cpu(ri->gid);
145
146
147	old_metadata = f->metadata;
148
149	if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
150	jffs2_truncate_fraglist (c, &f->fragtree, iattr->ia_size);
151
152	if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
153	jffs2_add_full_dnode_to_inode(c, f, new_metadata);
154	inode->i_size = iattr->ia_size;
155	f->metadata = NULL;
156	} else {
157	f->metadata = new_metadata;
158	}
159	if (old_metadata) {
160	jffs2_mark_node_obsolete(c, old_metadata->raw);
161	jffs2_free_full_dnode(old_metadata);
162	}
163	jffs2_free_raw_inode(ri);
164
165	up(&f->sem);
166	jffs2_complete_reservation(c);
167
168	/* We have to do the vmtruncate() without f->sem held, since
169	some pages may be locked and waiting for it in readpage().
170	We are protected from a simultaneous write() extending i_size
171	back past iattr->ia_size, because do_truncate() holds the
172	generic inode semaphore. */
173	if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
174	vmtruncate(inode, iattr->ia_size);
175
176	return 0;
177	}
178
179	int jffs2_setattr(struct dentry dentry, struct iattr iattr)
180	{
181	return jffs2_do_setattr(dentry->d_inode, iattr);
182	}
183
184	int jffs2_statfs(struct super_block sb, struct kstatfs buf)
185	{
186	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
187	unsigned long avail;
188
189	buf->f_type = JFFS2_SUPER_MAGIC;
190	buf->f_bsize = 1 << PAGE_SHIFT;
191	buf->f_blocks = c->flash_size >> PAGE_SHIFT;
192	buf->f_files = 0;
193	buf->f_ffree = 0;
194	buf->f_namelen = JFFS2_MAX_NAME_LEN;
195
196	spin_lock(&c->erase_completion_lock);
1da177e4 LT	197	avail = c->dirty_size + c->free_size;
	198	if (avail > c->sector_size * c->resv_blocks_write)
	199	avail -= c->sector_size * c->resv_blocks_write;
	200	else
	201	avail = 0;
e0c8e42f	202	spin_unlock(&c->erase_completion_lock);
1da177e4 LT	203
	204	buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
	205
1da177e4 LT	206	return 0;
	207	}
	208
	209
	210	void jffs2_clear_inode (struct inode *inode)
	211	{
	212	/* We can forget about this inode for now - drop all
	213	* the nodelists associated with it, etc.
	214	*/
	215	struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
	216	struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
	217
	218	D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
	219
	220	jffs2_do_clear_inode(c, f);
	221	}
	222
	223	void jffs2_read_inode (struct inode *inode)
	224	{
	225	struct jffs2_inode_info *f;
	226	struct jffs2_sb_info *c;
	227	struct jffs2_raw_inode latest_node;
	228	int ret;
	229
	230	D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
	231
	232	f = JFFS2_INODE_INFO(inode);
	233	c = JFFS2_SB_INFO(inode->i_sb);
	234
	235	jffs2_init_inode_info(f);
	236
	237	ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
	238
	239	if (ret) {
	240	make_bad_inode(inode);
	241	up(&f->sem);
	242	return;
	243	}
	244	inode->i_mode = jemode_to_cpu(latest_node.mode);
	245	inode->i_uid = je16_to_cpu(latest_node.uid);
	246	inode->i_gid = je16_to_cpu(latest_node.gid);
	247	inode->i_size = je32_to_cpu(latest_node.isize);
	248	inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
	249	inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
	250	inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
	251
	252	inode->i_nlink = f->inocache->nlink;
	253
	254	inode->i_blksize = PAGE_SIZE;
	255	inode->i_blocks = (inode->i_size + 511) >> 9;
	256
	257	switch (inode->i_mode & S_IFMT) {
	258	jint16_t rdev;
	259
	260	case S_IFLNK:
	261	inode->i_op = &jffs2_symlink_inode_operations;
	262	break;
	263
	264	case S_IFDIR:
	265	{
	266	struct jffs2_full_dirent *fd;
	267
	268	for (fd=f->dents; fd; fd = fd->next) {
	269	if (fd->type == DT_DIR && fd->ino)
270	inode->i_nlink++;
271	}
272	/* and '..' */
273	inode->i_nlink++;
274	/* Root dir gets i_nlink 3 for some reason */
275	if (inode->i_ino == 1)
276	inode->i_nlink++;
277
278	inode->i_op = &jffs2_dir_inode_operations;
279	inode->i_fop = &jffs2_dir_operations;
280	break;
281	}
282	case S_IFREG:
283	inode->i_op = &jffs2_file_inode_operations;
284	inode->i_fop = &jffs2_file_operations;
285	inode->i_mapping->a_ops = &jffs2_file_address_operations;
286	inode->i_mapping->nrpages = 0;
287	break;
288
289	case S_IFBLK:
290	case S_IFCHR:
291	/* Read the device numbers from the media */
292	D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
293	if (jffs2_read_dnode(c, f, f->metadata, (char *)&rdev, 0, sizeof(rdev)) < 0) {
294	/* Eep */
295	printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
296	up(&f->sem);
297	jffs2_do_clear_inode(c, f);
298	make_bad_inode(inode);
299	return;
300	}
301
302	case S_IFSOCK:
303	case S_IFIFO:
304	inode->i_op = &jffs2_file_inode_operations;
305	init_special_inode(inode, inode->i_mode,
306	old_decode_dev((je16_to_cpu(rdev))));
307	break;
308
309	default:
310	printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
311	}
312
313	up(&f->sem);
314
315	D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
316	}
317
318	void jffs2_dirty_inode(struct inode *inode)
319	{
320	struct iattr iattr;
321
322	if (!(inode->i_state & I_DIRTY_DATASYNC)) {
323	D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
324	return;
325	}
326
327	D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
328
329	iattr.ia_valid = ATTR_MODE\|ATTR_UID\|ATTR_GID\|ATTR_ATIME\|ATTR_MTIME\|ATTR_CTIME;
330	iattr.ia_mode = inode->i_mode;
331	iattr.ia_uid = inode->i_uid;
332	iattr.ia_gid = inode->i_gid;
333	iattr.ia_atime = inode->i_atime;
334	iattr.ia_mtime = inode->i_mtime;
335	iattr.ia_ctime = inode->i_ctime;
336
337	jffs2_do_setattr(inode, &iattr);
338	}
339
340	int jffs2_remount_fs (struct super_block sb, int flags, char *data)
341	{
342	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
343
344	if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
345	return -EROFS;
346
347	/* We stop if it was running, then restart if it needs to.
348	This also catches the case where it was stopped and this
349	is just a remount to restart it.
350	Flush the writebuffer, if neccecary, else we loose it */
351	if (!(sb->s_flags & MS_RDONLY)) {
352	jffs2_stop_garbage_collect_thread(c);
353	down(&c->alloc_sem);
354	jffs2_flush_wbuf_pad(c);
355	up(&c->alloc_sem);
356	}
357
358	if (!(*flags & MS_RDONLY))
359	jffs2_start_garbage_collect_thread(c);
360
361	*flags \|= MS_NOATIME;
362
363	return 0;
364	}
365
366	void jffs2_write_super (struct super_block *sb)
367	{
368	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
369	sb->s_dirt = 0;
370
371	if (sb->s_flags & MS_RDONLY)
372	return;
373
374	D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
375	jffs2_garbage_collect_trigger(c);
376	jffs2_erase_pending_blocks(c, 0);
377	jffs2_flush_wbuf_gc(c, 0);
378	}
379
380
381	/* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
382	fill in the raw_inode while you're at it. */
383	struct inode jffs2_new_inode (struct inode dir_i, int mode, struct jffs2_raw_inode *ri)
384	{
385	struct inode *inode;
386	struct super_block *sb = dir_i->i_sb;
387	struct jffs2_sb_info *c;
388	struct jffs2_inode_info *f;
389	int ret;
390
391	D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
392
393	c = JFFS2_SB_INFO(sb);
394
395	inode = new_inode(sb);
396
397	if (!inode)
398	return ERR_PTR(-ENOMEM);
399
400	f = JFFS2_INODE_INFO(inode);
401	jffs2_init_inode_info(f);
402
403	memset(ri, 0, sizeof(*ri));
404	/* Set OS-specific defaults for new inodes */
405	ri->uid = cpu_to_je16(current->fsuid);
406
407	if (dir_i->i_mode & S_ISGID) {
408	ri->gid = cpu_to_je16(dir_i->i_gid);
409	if (S_ISDIR(mode))
410	mode \|= S_ISGID;
411	} else {
412	ri->gid = cpu_to_je16(current->fsgid);
413	}
414	ri->mode = cpu_to_jemode(mode);
415	ret = jffs2_do_new_inode (c, f, mode, ri);
416	if (ret) {
417	make_bad_inode(inode);
418	iput(inode);
419	return ERR_PTR(ret);
420	}
421	inode->i_nlink = 1;
422	inode->i_ino = je32_to_cpu(ri->ino);
423	inode->i_mode = jemode_to_cpu(ri->mode);
424	inode->i_gid = je16_to_cpu(ri->gid);
425	inode->i_uid = je16_to_cpu(ri->uid);
426	inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
427	ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
428
429	inode->i_blksize = PAGE_SIZE;
430	inode->i_blocks = 0;
431	inode->i_size = 0;
432
433	insert_inode_hash(inode);
434
435	return inode;
436	}
437
438
439	int jffs2_do_fill_super(struct super_block sb, void data, int silent)
440	{
441	struct jffs2_sb_info *c;
442	struct inode *root_i;
443	int ret;
444	size_t blocks;
445
446	c = JFFS2_SB_INFO(sb);
447
2f82ce1e	448	#ifndef CONFIG_JFFS2_FS_WRITEBUFFER
1da177e4 LT	449	if (c->mtd->type == MTD_NANDFLASH) {
	450	printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
	451	return -EINVAL;
	452	}
8f15fd55 AV	453	if (c->mtd->type == MTD_DATAFLASH) {
	454	printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
	455	return -EINVAL;
	456	}
	457	#endif
1da177e4 LT	458
	459	c->flash_size = c->mtd->size;
	460
	461	/*
	462	* Check, if we have to concatenate physical blocks to larger virtual blocks
	463	* to reduce the memorysize for c->blocks. (kmalloc allows max. 128K allocation)
	464	*/
	465	c->sector_size = c->mtd->erasesize;
	466	blocks = c->flash_size / c->sector_size;
	467	if (!(c->mtd->flags & MTD_NO_VIRTBLOCKS)) {
	468	while ((blocks * sizeof (struct jffs2_eraseblock)) > (128 * 1024)) {
	469	blocks >>= 1;
	470	c->sector_size <<= 1;
	471	}
	472	}
	473
	474	/*
	475	* Size alignment check
	476	*/
	477	if ((c->sector_size * blocks) != c->flash_size) {
	478	c->flash_size = c->sector_size * blocks;
	479	printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
	480	c->flash_size / 1024);
	481	}
	482
	483	if (c->sector_size != c->mtd->erasesize)
	484	printk(KERN_INFO "jffs2: Erase block size too small (%dKiB). Using virtual blocks size (%dKiB) instead\n",
	485	c->mtd->erasesize / 1024, c->sector_size / 1024);
	486
	487	if (c->flash_size < 5*c->sector_size) {
	488	printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
	489	return -EINVAL;
	490	}
	491
	492	c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
	493	/* Joern -- stick alignment for weird 8-byte-page flash here */
	494
	495	/* NAND (or other bizarre) flash... do setup accordingly */
	496	ret = jffs2_flash_setup(c);
	497	if (ret)
	498	return ret;
	499
	500	c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
	501	if (!c->inocache_list) {
	502	ret = -ENOMEM;
	503	goto out_wbuf;
	504	}
	505	memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
	506
	507	if ((ret = jffs2_do_mount_fs(c)))
	508	goto out_inohash;
	509
	510	ret = -EINVAL;
	511
	512	D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
	513	root_i = iget(sb, 1);
	514	if (is_bad_inode(root_i)) {
	515	D1(printk(KERN_WARNING "get root inode failed\n"));
6dac02a5	516	goto out_root_i;
1da177e4 LT	517	}
	518
	519	D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
	520	sb->s_root = d_alloc_root(root_i);
	521	if (!sb->s_root)
	522	goto out_root_i;
	523
1da177e4	524	sb->s_maxbytes = 0xFFFFFFFF;
1da177e4 LT	525	sb->s_blocksize = PAGE_CACHE_SIZE;
	526	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
	527	sb->s_magic = JFFS2_SUPER_MAGIC;
	528	if (!(sb->s_flags & MS_RDONLY))
	529	jffs2_start_garbage_collect_thread(c);
	530	return 0;
	531
	532	out_root_i:
	533	iput(root_i);
1da177e4 LT	534	jffs2_free_ino_caches(c);
	535	jffs2_free_raw_node_refs(c);
	536	if (c->mtd->flags & MTD_NO_VIRTBLOCKS)
	537	vfree(c->blocks);
	538	else
	539	kfree(c->blocks);
	540	out_inohash:
	541	kfree(c->inocache_list);
	542	out_wbuf:
	543	jffs2_flash_cleanup(c);
	544
	545	return ret;
	546	}
	547
	548	void jffs2_gc_release_inode(struct jffs2_sb_info *c,
	549	struct jffs2_inode_info *f)
	550	{
	551	iput(OFNI_EDONI_2SFFJ(f));
	552	}
	553
	554	struct jffs2_inode_info jffs2_gc_fetch_inode(struct jffs2_sb_info c,
	555	int inum, int nlink)
	556	{
	557	struct inode *inode;
	558	struct jffs2_inode_cache *ic;
	559	if (!nlink) {
	560	/* The inode has zero nlink but its nodes weren't yet marked
	561	obsolete. This has to be because we're still waiting for
	562	the final (close() and) iput() to happen.
	563
	564	There's a possibility that the final iput() could have
	565	happened while we were contemplating. In order to ensure
	566	that we don't cause a new read_inode() (which would fail)
	567	for the inode in question, we use ilookup() in this case
	568	instead of iget().
	569
	570	The nlink can't _become_ zero at this point because we're
	571	holding the alloc_sem, and jffs2_do_unlink() would also
	572	need that while decrementing nlink on any inode.
	573	*/
	574	inode = ilookup(OFNI_BS_2SFFJ(c), inum);
	575	if (!inode) {
	576	D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
	577	inum));
	578
	579	spin_lock(&c->inocache_lock);
	580	ic = jffs2_get_ino_cache(c, inum);
	581	if (!ic) {
	582	D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
	583	spin_unlock(&c->inocache_lock);
	584	return NULL;
	585	}
	586	if (ic->state != INO_STATE_CHECKEDABSENT) {
	587	/* Wait for progress. Don't just loop */
	588	D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
	589	ic->ino, ic->state));
	590	sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
	591	} else {
	592	spin_unlock(&c->inocache_lock);
	593	}
	594
	595	return NULL;
	596	}
	597	} else {
598	/* Inode has links to it still; they're not going away because
599	jffs2_do_unlink() would need the alloc_sem and we have it.
600	Just iget() it, and if read_inode() is necessary that's OK.
601	*/
602	inode = iget(OFNI_BS_2SFFJ(c), inum);
603	if (!inode)
604	return ERR_PTR(-ENOMEM);
605	}
606	if (is_bad_inode(inode)) {
607	printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n",
608	inum, nlink);
609	/* NB. This will happen again. We need to do something appropriate here. */
610	iput(inode);
611	return ERR_PTR(-EIO);
612	}
613
614	return JFFS2_INODE_INFO(inode);
615	}
616
617	unsigned char jffs2_gc_fetch_page(struct jffs2_sb_info c,
618	struct jffs2_inode_info *f,
619	unsigned long offset,
620	unsigned long *priv)
621	{
622	struct inode *inode = OFNI_EDONI_2SFFJ(f);
623	struct page *pg;
624
625	pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
626	(void *)jffs2_do_readpage_unlock, inode);
627	if (IS_ERR(pg))
628	return (void *)pg;
629
630	*priv = (unsigned long)pg;
631	return kmap(pg);
632	}
633
634	void jffs2_gc_release_page(struct jffs2_sb_info *c,
635	unsigned char *ptr,
636	unsigned long *priv)
637	{
638	struct page pg = (void )*priv;
639
640	kunmap(pg);
641	page_cache_release(pg);
642	}
643
644	static int jffs2_flash_setup(struct jffs2_sb_info *c) {
645	int ret = 0;
646
647	if (jffs2_cleanmarker_oob(c)) {
648	/* NAND flash... do setup accordingly */
649	ret = jffs2_nand_flash_setup(c);
650	if (ret)
651	return ret;
652	}
653
654	/* add setups for other bizarre flashes here... */
655	if (jffs2_nor_ecc(c)) {
656	ret = jffs2_nor_ecc_flash_setup(c);
657	if (ret)
658	return ret;
659	}
8f15fd55 AV	660
	661	/* and Dataflash */
	662	if (jffs2_dataflash(c)) {
	663	ret = jffs2_dataflash_setup(c);
	664	if (ret)
	665	return ret;
	666	}
	667
1da177e4 LT	668	return ret;
	669	}
	670
	671	void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
	672
	673	if (jffs2_cleanmarker_oob(c)) {
	674	jffs2_nand_flash_cleanup(c);
	675	}
	676
	677	/* add cleanups for other bizarre flashes here... */
	678	if (jffs2_nor_ecc(c)) {
	679	jffs2_nor_ecc_flash_cleanup(c);
	680	}
8f15fd55 AV	681
	682	/* and DataFlash */
	683	if (jffs2_dataflash(c)) {
	684	jffs2_dataflash_cleanup(c);
	685	}
1da177e4	686	}