[JFFS2] semaphore->mutex conversion

	alloc_sem

	---------

The alloc_sem is a per-filesystem semaphore, used primarily to ensure

The alloc_sem is a per-filesystem mutex, used primarily to ensure

contiguous allocation of space on the medium. It is automatically

obtained during space allocations (jffs2_reserve_space()) and freed

upon write completion (jffs2_complete_reservation()). Note that

Ordering constraints: See f->sem.

	File Semaphore f->sem

	File Mutex f->sem

	---------------------

This is the JFFS2-internal equivalent of the inode semaphore i->i_sem.

This is the JFFS2-internal equivalent of the inode mutex i->i_sem.

It protects the contents of the jffs2_inode_info private inode data,

including the linked list of node fragments (but see the notes below on

erase_completion_lock), etc.

before calling the space allocation functions.

Instead of playing such games, we just have an extra internal

semaphore, which is obtained by the garbage collection code and also

mutex, which is obtained by the garbage collection code and also

by the normal file system code _after_ allocation of space.

Ordering constraints: 

	1. Never attempt to allocate space or lock alloc_sem with 

	   any f->sem held.

	2. Never attempt to lock two file semaphores in one thread.

	2. Never attempt to lock two file mutexes in one thread.

	   No ordering rules have been made for doing so.

Note that the per-inode list of physical nodes (f->nodes) is a special

case. Any changes to _valid_ nodes (i.e. ->flash_offset & 1 == 0) in

the list are protected by the file semaphore f->sem. But the erase

code may remove _obsolete_ nodes from the list while holding only the

the list are protected by the file mutex f->sem. But the erase code

may remove _obsolete_ nodes from the list while holding only the

erase_completion_lock. So you can walk the list only while holding the

erase_completion_lock, and can drop the lock temporarily mid-walk as

long as the pointer you're holding is to a _valid_ node, not an

	erase_free_sem

	--------------

This semaphore is only used by the erase code which frees obsolete

node references and the jffs2_garbage_collect_deletion_dirent()

function. The latter function on NAND flash must read _obsolete_ nodes

to determine whether the 'deletion dirent' under consideration can be

This mutex is only used by the erase code which frees obsolete node

references and the jffs2_garbage_collect_deletion_dirent() function.

The latter function on NAND flash must read _obsolete_ nodes to

determine whether the 'deletion dirent' under consideration can be

discarded or whether it is still required to show that an inode has

been unlinked. Because reading from the flash may sleep, the

erase_completion_lock cannot be held, so an alternative, more

void

__jffs2_dbg_fragtree_paranoia_check(struct jffs2_inode_info *f)

{

	down(&f->sem);

	mutex_lock(&f->sem);

	__jffs2_dbg_fragtree_paranoia_check_nolock(f);

	up(&f->sem);

	mutex_unlock(&f->sem);

}

void

void

__jffs2_dbg_dump_fragtree(struct jffs2_inode_info *f)

{

	down(&f->sem);

	mutex_lock(&f->sem);

	jffs2_dbg_dump_fragtree_nolock(f);

	up(&f->sem);

	mutex_unlock(&f->sem);

}

void

	dir_f = JFFS2_INODE_INFO(dir_i);

	c = JFFS2_SB_INFO(dir_i->i_sb);

	down(&dir_f->sem);

	mutex_lock(&dir_f->sem);

	/* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */

	for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= target->d_name.hash; fd_list = fd_list->next) {

	}

	if (fd)

		ino = fd->ino;

	up(&dir_f->sem);

	mutex_unlock(&dir_f->sem);

	if (ino) {

		inode = jffs2_iget(dir_i->i_sb, ino);

		if (IS_ERR(inode)) {

	}

	curofs=1;

	down(&f->sem);

	mutex_lock(&f->sem);

	for (fd = f->dents; fd; fd = fd->next) {

		curofs++;

			break;

		offset++;

	}

	up(&f->sem);

	mutex_unlock(&f->sem);

 out:

	filp->f_pos = offset;

	return 0;

	ret = jffs2_do_link(c, dir_f, f->inocache->ino, type, dentry->d_name.name, dentry->d_name.len, now);

	if (!ret) {

		down(&f->sem);

		mutex_lock(&f->sem);

		old_dentry->d_inode->i_nlink = ++f->inocache->nlink;

		up(&f->sem);

		mutex_unlock(&f->sem);

		d_instantiate(dentry, old_dentry->d_inode);

		dir_i->i_mtime = dir_i->i_ctime = ITIME(now);

		atomic_inc(&old_dentry->d_inode->i_count);

	if (IS_ERR(fn)) {

		/* Eeek. Wave bye bye */

		up(&f->sem);

		mutex_unlock(&f->sem);

		jffs2_complete_reservation(c);

		jffs2_clear_inode(inode);

		return PTR_ERR(fn);

	f->target = kmalloc(targetlen + 1, GFP_KERNEL);

	if (!f->target) {

		printk(KERN_WARNING "Can't allocate %d bytes of memory\n", targetlen + 1);

		up(&f->sem);

		mutex_unlock(&f->sem);

		jffs2_complete_reservation(c);

		jffs2_clear_inode(inode);

		return -ENOMEM;

	   obsoleted by the first data write

	*/

	f->metadata = fn;

	up(&f->sem);

	mutex_unlock(&f->sem);

	jffs2_complete_reservation(c);

	}

	dir_f = JFFS2_INODE_INFO(dir_i);

	down(&dir_f->sem);

	mutex_lock(&dir_f->sem);

	rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);

	rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);

		   as if it were the final unlink() */

		jffs2_complete_reservation(c);

		jffs2_free_raw_dirent(rd);

		up(&dir_f->sem);

		mutex_unlock(&dir_f->sem);

		jffs2_clear_inode(inode);

		return PTR_ERR(fd);

	}

	   one if necessary. */

	jffs2_add_fd_to_list(c, fd, &dir_f->dents);

	up(&dir_f->sem);

	mutex_unlock(&dir_f->sem);

	jffs2_complete_reservation(c);

	d_instantiate(dentry, inode);

	if (IS_ERR(fn)) {

		/* Eeek. Wave bye bye */

		up(&f->sem);

		mutex_unlock(&f->sem);

		jffs2_complete_reservation(c);

		jffs2_clear_inode(inode);

		return PTR_ERR(fn);

	   obsoleted by the first data write

	*/

	f->metadata = fn;

	up(&f->sem);

	mutex_unlock(&f->sem);

	jffs2_complete_reservation(c);

	}

	dir_f = JFFS2_INODE_INFO(dir_i);

	down(&dir_f->sem);

	mutex_lock(&dir_f->sem);

	rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);

	rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);

		   as if it were the final unlink() */

		jffs2_complete_reservation(c);

		jffs2_free_raw_dirent(rd);

		up(&dir_f->sem);

		mutex_unlock(&dir_f->sem);

		jffs2_clear_inode(inode);

		return PTR_ERR(fd);

	}

	   one if necessary. */

	jffs2_add_fd_to_list(c, fd, &dir_f->dents);

	up(&dir_f->sem);

	mutex_unlock(&dir_f->sem);

	jffs2_complete_reservation(c);

	d_instantiate(dentry, inode);

	if (IS_ERR(fn)) {

		/* Eeek. Wave bye bye */

		up(&f->sem);

		mutex_unlock(&f->sem);

		jffs2_complete_reservation(c);

		jffs2_clear_inode(inode);

		return PTR_ERR(fn);

	   obsoleted by the first data write

	*/

	f->metadata = fn;

	up(&f->sem);

	mutex_unlock(&f->sem);

	jffs2_complete_reservation(c);

	}

	dir_f = JFFS2_INODE_INFO(dir_i);

	down(&dir_f->sem);

	mutex_lock(&dir_f->sem);

	rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);

	rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);

		   as if it were the final unlink() */

		jffs2_complete_reservation(c);

		jffs2_free_raw_dirent(rd);

		up(&dir_f->sem);

		mutex_unlock(&dir_f->sem);

		jffs2_clear_inode(inode);

		return PTR_ERR(fd);

	}

	   one if necessary. */

	jffs2_add_fd_to_list(c, fd, &dir_f->dents);

	up(&dir_f->sem);

	mutex_unlock(&dir_f->sem);

	jffs2_complete_reservation(c);

	d_instantiate(dentry, inode);

		if (S_ISDIR(new_dentry->d_inode->i_mode)) {

			struct jffs2_full_dirent *fd;

			down(&victim_f->sem);

			mutex_lock(&victim_f->sem);

			for (fd = victim_f->dents; fd; fd = fd->next) {

				if (fd->ino) {

					up(&victim_f->sem);

					mutex_unlock(&victim_f->sem);

					return -ENOTEMPTY;

				}

			}

			up(&victim_f->sem);

			mutex_unlock(&victim_f->sem);

		}

	}

		/* Don't oops if the victim was a dirent pointing to an

		   inode which didn't exist. */

		if (victim_f->inocache) {

			down(&victim_f->sem);

			mutex_lock(&victim_f->sem);

			victim_f->inocache->nlink--;

			up(&victim_f->sem);

			mutex_unlock(&victim_f->sem);

		}

	}

	if (ret) {

		/* Oh shit. We really ought to make a single node which can do both atomically */

		struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode);

		down(&f->sem);

		mutex_lock(&f->sem);

		inc_nlink(old_dentry->d_inode);

		if (f->inocache)

			f->inocache->nlink++;

		up(&f->sem);

		mutex_unlock(&f->sem);

		printk(KERN_NOTICE "jffs2_rename(): Link succeeded, unlink failed (err %d). You now have a hard link\n", ret);

		/* Might as well let the VFS know */

	instr = kmalloc(sizeof(struct erase_info) + sizeof(struct erase_priv_struct), GFP_KERNEL);

	if (!instr) {

		printk(KERN_WARNING "kmalloc for struct erase_info in jffs2_erase_block failed. Refiling block for later\n");

		down(&c->erase_free_sem);

		mutex_lock(&c->erase_free_sem);

		spin_lock(&c->erase_completion_lock);

		list_move(&jeb->list, &c->erase_pending_list);

		c->erasing_size -= c->sector_size;

		c->dirty_size += c->sector_size;

		jeb->dirty_size = c->sector_size;

		spin_unlock(&c->erase_completion_lock);

		up(&c->erase_free_sem);

		mutex_unlock(&c->erase_free_sem);

		return;

	}

	if (ret == -ENOMEM || ret == -EAGAIN) {

		/* Erase failed immediately. Refile it on the list */

		D1(printk(KERN_DEBUG "Erase at 0x%08x failed: %d. Refiling on erase_pending_list\n", jeb->offset, ret));

		down(&c->erase_free_sem);

		mutex_lock(&c->erase_free_sem);

		spin_lock(&c->erase_completion_lock);

		list_move(&jeb->list, &c->erase_pending_list);

		c->erasing_size -= c->sector_size;

		c->dirty_size += c->sector_size;

		jeb->dirty_size = c->sector_size;

		spin_unlock(&c->erase_completion_lock);

		up(&c->erase_free_sem);

		mutex_unlock(&c->erase_free_sem);

		return;

	}

{

	struct jffs2_eraseblock *jeb;

	down(&c->erase_free_sem);

	mutex_lock(&c->erase_free_sem);

	spin_lock(&c->erase_completion_lock);

			jeb = list_entry(c->erase_complete_list.next, struct jffs2_eraseblock, list);

			list_del(&jeb->list);

			spin_unlock(&c->erase_completion_lock);

			up(&c->erase_free_sem);

			mutex_unlock(&c->erase_free_sem);

			jffs2_mark_erased_block(c, jeb);

			if (!--count) {

			jffs2_free_jeb_node_refs(c, jeb);

			list_add(&jeb->list, &c->erasing_list);

			spin_unlock(&c->erase_completion_lock);

			up(&c->erase_free_sem);

			mutex_unlock(&c->erase_free_sem);

			jffs2_erase_block(c, jeb);

		/* Be nice */

		yield();

		down(&c->erase_free_sem);

		mutex_lock(&c->erase_free_sem);

		spin_lock(&c->erase_completion_lock);

	}

	spin_unlock(&c->erase_completion_lock);

	up(&c->erase_free_sem);

	mutex_unlock(&c->erase_free_sem);

 done:

	D1(printk(KERN_DEBUG "jffs2_erase_pending_blocks completed\n"));

}

static void jffs2_erase_succeeded(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)

{

	D1(printk(KERN_DEBUG "Erase completed successfully at 0x%08x\n", jeb->offset));

	down(&c->erase_free_sem);

	mutex_lock(&c->erase_free_sem);

	spin_lock(&c->erase_completion_lock);

	list_move_tail(&jeb->list, &c->erase_complete_list);

	spin_unlock(&c->erase_completion_lock);

	up(&c->erase_free_sem);

	mutex_unlock(&c->erase_free_sem);

	/* Ensure that kupdated calls us again to mark them clean */

	jffs2_erase_pending_trigger(c);

}

		   failed too many times. */

		if (!jffs2_write_nand_badblock(c, jeb, bad_offset)) {

			/* We'd like to give this block another try. */

			down(&c->erase_free_sem);

			mutex_lock(&c->erase_free_sem);

			spin_lock(&c->erase_completion_lock);

			list_move(&jeb->list, &c->erase_pending_list);

			c->erasing_size -= c->sector_size;

			c->dirty_size += c->sector_size;

			jeb->dirty_size = c->sector_size;

			spin_unlock(&c->erase_completion_lock);

			up(&c->erase_free_sem);

			mutex_unlock(&c->erase_free_sem);

			return;

		}

	}

	down(&c->erase_free_sem);

	mutex_lock(&c->erase_free_sem);

	spin_lock(&c->erase_completion_lock);

	c->erasing_size -= c->sector_size;

	c->bad_size += c->sector_size;

	list_move(&jeb->list, &c->bad_list);

	c->nr_erasing_blocks--;

	spin_unlock(&c->erase_completion_lock);

	up(&c->erase_free_sem);

	mutex_unlock(&c->erase_free_sem);

	wake_up(&c->erase_wait);

}

		jffs2_link_node_ref(c, jeb, jeb->offset | REF_NORMAL, c->cleanmarker_size, NULL);

	}

	down(&c->erase_free_sem);

	mutex_lock(&c->erase_free_sem);

	spin_lock(&c->erase_completion_lock);

	c->erasing_size -= c->sector_size;

	c->free_size += jeb->free_size;

	c->nr_erasing_blocks--;

	c->nr_free_blocks++;

	spin_unlock(&c->erase_completion_lock);

	up(&c->erase_free_sem);

	mutex_unlock(&c->erase_free_sem);

	wake_up(&c->erase_wait);

	return;

filebad:

	down(&c->erase_free_sem);

	mutex_lock(&c->erase_free_sem);

	spin_lock(&c->erase_completion_lock);

	/* Stick it on a list (any list) so erase_failed can take it

	   right off again.  Silly, but shouldn't happen often. */

	list_add(&jeb->list, &c->erasing_list);

	spin_unlock(&c->erase_completion_lock);

	up(&c->erase_free_sem);

	mutex_unlock(&c->erase_free_sem);

	jffs2_erase_failed(c, jeb, bad_offset);

	return;

refile:

	/* Stick it back on the list from whence it came and come back later */

	jffs2_erase_pending_trigger(c);

	down(&c->erase_free_sem);

	mutex_lock(&c->erase_free_sem);

	spin_lock(&c->erase_completion_lock);

	list_add(&jeb->list, &c->erase_complete_list);

	spin_unlock(&c->erase_completion_lock);

	up(&c->erase_free_sem);

	mutex_unlock(&c->erase_free_sem);

	return;

}

	struct jffs2_inode_info *f = JFFS2_INODE_INFO(pg->mapping->host);

	int ret;

	down(&f->sem);

	mutex_lock(&f->sem);

	ret = jffs2_do_readpage_unlock(pg->mapping->host, pg);

	up(&f->sem);

	mutex_unlock(&f->sem);

	return ret;

}

		if (ret)

			goto out_page;

		down(&f->sem);

		mutex_lock(&f->sem);

		memset(&ri, 0, sizeof(ri));

		ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);

		if (IS_ERR(fn)) {

			ret = PTR_ERR(fn);

			jffs2_complete_reservation(c);

			up(&f->sem);

			mutex_unlock(&f->sem);

			goto out_page;

		}

		ret = jffs2_add_full_dnode_to_inode(c, f, fn);

			jffs2_mark_node_obsolete(c, fn->raw);

			jffs2_free_full_dnode(fn);

			jffs2_complete_reservation(c);

			up(&f->sem);

			mutex_unlock(&f->sem);

			goto out_page;

		}

		jffs2_complete_reservation(c);

		inode->i_size = pageofs;

		up(&f->sem);

		mutex_unlock(&f->sem);

	}

	/*

	 * case of a short-copy.

	 */

	if (!PageUptodate(pg)) {

		down(&f->sem);

		mutex_lock(&f->sem);

		ret = jffs2_do_readpage_nolock(inode, pg);

		up(&f->sem);

		mutex_unlock(&f->sem);

		if (ret)

			goto out_page;

	}