Commit 6c5daf01 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6 

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6:
  truncate: use new helpers
  truncate: new helpers
  fs: fix overflow in sys_mount() for in-kernel calls
  fs: Make unload_nls() NULL pointer safe
  freeze_bdev: grab active reference to frozen superblocks
  freeze_bdev: kill bd_mount_sem
  exofs: remove BKL from super operations
  fs/romfs: correct error-handling code
  vfs: seq_file: add helpers for data filling
  vfs: remove redundant position check in do_sendfile
  vfs: change sb->s_maxbytes to a loff_t
  vfs: explicitly cast s_maxbytes in fiemap_check_ranges
  libfs: return error code on failed attr set
  seq_file: return a negative error code when seq_path_root() fails.
  vfs: optimize touch_time() too
  vfs: optimization for touch_atime()
  vfs: split generic_forget_inode() so that hugetlbfs does not have to copy it
  fs/inode.c: add dev-id and inode number for debugging in init_special_inode()
  libfs: make simple_read_from_buffer conventional
parents 6d39b27f c08d3b0e

Documentation/vm/locking

+1 −1
Original line number Diff line number Diff line
@@ -80,7 +80,7 @@ Note: PTL can also be used to guarantee that no new clones using the 
mm start up ... this is a loose form of stability on mm_users. For

example, it is used in copy_mm to protect against a racing tlb_gather_mmu

single address space optimization, so that the zap_page_range (from

vmtruncate) does not lose sending ipi's to cloned threads that might 

truncate) does not lose sending ipi's to cloned threads that might

be spawned underneath it and go to user mode to drag in pte's into tlbs.



swap_lock

fs/attr.c

+44 −2
Original line number Diff line number Diff line
@@ -18,7 +18,7 @@ 
/* Taken over from the old code... */



/* POSIX UID/GID verification for setting inode attributes. */

int inode_change_ok(struct inode *inode, struct iattr *attr)

int inode_change_ok(const struct inode *inode, struct iattr *attr)

{

	int retval = -EPERM;

	unsigned int ia_valid = attr->ia_valid;
@@ -60,9 +60,51 @@ fine: 
error:

	return retval;

}



EXPORT_SYMBOL(inode_change_ok);



/**

 * inode_newsize_ok - may this inode be truncated to a given size

 * @inode:	the inode to be truncated

 * @offset:	the new size to assign to the inode

 * @Returns:	0 on success, -ve errno on failure

 *

 * inode_newsize_ok will check filesystem limits and ulimits to check that the

 * new inode size is within limits. inode_newsize_ok will also send SIGXFSZ

 * when necessary. Caller must not proceed with inode size change if failure is

 * returned. @inode must be a file (not directory), with appropriate

 * permissions to allow truncate (inode_newsize_ok does NOT check these

 * conditions).

 *

 * inode_newsize_ok must be called with i_mutex held.

 */

int inode_newsize_ok(const struct inode *inode, loff_t offset)

{

	if (inode->i_size < offset) {

		unsigned long limit;



		limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;

		if (limit != RLIM_INFINITY && offset > limit)

			goto out_sig;

		if (offset > inode->i_sb->s_maxbytes)

			goto out_big;

	} else {

		/*

		 * truncation of in-use swapfiles is disallowed - it would

		 * cause subsequent swapout to scribble on the now-freed

		 * blocks.

		 */

		if (IS_SWAPFILE(inode))

			return -ETXTBSY;

	}



	return 0;

out_sig:

	send_sig(SIGXFSZ, current, 0);

out_big:

	return -EFBIG;

}

EXPORT_SYMBOL(inode_newsize_ok);



int inode_setattr(struct inode * inode, struct iattr * attr)

{

	unsigned int ia_valid = attr->ia_valid;

fs/befs/linuxvfs.c

+1 −6
Original line number Diff line number Diff line
@@ -737,12 +737,7 @@ befs_put_super(struct super_block *sb) 
{

	kfree(BEFS_SB(sb)->mount_opts.iocharset);

	BEFS_SB(sb)->mount_opts.iocharset = NULL;



	if (BEFS_SB(sb)->nls) {

	unload_nls(BEFS_SB(sb)->nls);

		BEFS_SB(sb)->nls = NULL;

	}



	kfree(sb->s_fs_info);

	sb->s_fs_info = NULL;

}

fs/block_dev.c

+73 −67
Original line number Diff line number Diff line
@@ -216,8 +216,6 @@ EXPORT_SYMBOL(fsync_bdev); 
 * freeze_bdev  --  lock a filesystem and force it into a consistent state

 * @bdev:	blockdevice to lock

 *

 * This takes the block device bd_mount_sem to make sure no new mounts

 * happen on bdev until thaw_bdev() is called.

 * If a superblock is found on this device, we take the s_umount semaphore

 * on it to make sure nobody unmounts until the snapshot creation is done.

 * The reference counter (bd_fsfreeze_count) guarantees that only the last
@@ -232,17 +230,27 @@ struct super_block *freeze_bdev(struct block_device *bdev) 
	int error = 0;



	mutex_lock(&bdev->bd_fsfreeze_mutex);

	if (bdev->bd_fsfreeze_count > 0) {

		bdev->bd_fsfreeze_count++;

	if (++bdev->bd_fsfreeze_count > 1) {

		/*

		 * We don't even need to grab a reference - the first call

		 * to freeze_bdev grab an active reference and only the last

		 * thaw_bdev drops it.

		 */

		sb = get_super(bdev);

		drop_super(sb);

		mutex_unlock(&bdev->bd_fsfreeze_mutex);

		return sb;

	}



	sb = get_active_super(bdev);

	if (!sb)

		goto out;

	if (sb->s_flags & MS_RDONLY) {

		deactivate_locked_super(sb);

		mutex_unlock(&bdev->bd_fsfreeze_mutex);

		return sb;

	}

	bdev->bd_fsfreeze_count++;



	down(&bdev->bd_mount_sem);

	sb = get_super(bdev);

	if (sb && !(sb->s_flags & MS_RDONLY)) {

	sb->s_frozen = SB_FREEZE_WRITE;

	smp_wmb();
@@ -259,19 +267,18 @@ struct super_block *freeze_bdev(struct block_device *bdev) 
			printk(KERN_ERR

				"VFS:Filesystem freeze failed\n");

			sb->s_frozen = SB_UNFROZEN;

				drop_super(sb);

				up(&bdev->bd_mount_sem);

			deactivate_locked_super(sb);

			bdev->bd_fsfreeze_count--;

			mutex_unlock(&bdev->bd_fsfreeze_mutex);

			return ERR_PTR(error);

		}

	}

	}

	up_write(&sb->s_umount);



 out:

	sync_blockdev(bdev);

	mutex_unlock(&bdev->bd_fsfreeze_mutex);



	return sb;	/* thaw_bdev releases s->s_umount and bd_mount_sem */

	return sb;	/* thaw_bdev releases s->s_umount */

}

EXPORT_SYMBOL(freeze_bdev);
@@ -284,25 +291,24 @@ EXPORT_SYMBOL(freeze_bdev); 
 */

int thaw_bdev(struct block_device *bdev, struct super_block *sb)

{

	int error = 0;

	int error = -EINVAL;



	mutex_lock(&bdev->bd_fsfreeze_mutex);

	if (!bdev->bd_fsfreeze_count) {

		mutex_unlock(&bdev->bd_fsfreeze_mutex);

		return -EINVAL;

	}

	if (!bdev->bd_fsfreeze_count)

		goto out_unlock;



	bdev->bd_fsfreeze_count--;

	if (bdev->bd_fsfreeze_count > 0) {

		if (sb)

			drop_super(sb);

		mutex_unlock(&bdev->bd_fsfreeze_mutex);

		return 0;

	}

	error = 0;

	if (--bdev->bd_fsfreeze_count > 0)

		goto out_unlock;



	if (!sb)

		goto out_unlock;



	if (sb) {

	BUG_ON(sb->s_bdev != bdev);

		if (!(sb->s_flags & MS_RDONLY)) {

	down_write(&sb->s_umount);

	if (sb->s_flags & MS_RDONLY)

		goto out_deactivate;



	if (sb->s_op->unfreeze_fs) {

		error = sb->s_op->unfreeze_fs(sb);

		if (error) {
@@ -314,14 +320,15 @@ int thaw_bdev(struct block_device *bdev, struct super_block *sb) 
			return error;

		}

	}



	sb->s_frozen = SB_UNFROZEN;

	smp_wmb();

	wake_up(&sb->s_wait_unfrozen);

		}

		drop_super(sb);

	}



	up(&bdev->bd_mount_sem);

out_deactivate:

	if (sb)

		deactivate_locked_super(sb);

out_unlock:

	mutex_unlock(&bdev->bd_fsfreeze_mutex);

	return 0;

}
@@ -430,7 +437,6 @@ static void init_once(void *foo) 


	memset(bdev, 0, sizeof(*bdev));

	mutex_init(&bdev->bd_mutex);

	sema_init(&bdev->bd_mount_sem, 1);

	INIT_LIST_HEAD(&bdev->bd_inodes);

	INIT_LIST_HEAD(&bdev->bd_list);

#ifdef CONFIG_SYSFS

fs/buffer.c

+2 −8
Original line number Diff line number Diff line
@@ -2239,16 +2239,10 @@ int generic_cont_expand_simple(struct inode *inode, loff_t size) 
	struct address_space *mapping = inode->i_mapping;

	struct page *page;

	void *fsdata;

	unsigned long limit;

	int err;



	err = -EFBIG;

        limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;

	if (limit != RLIM_INFINITY && size > (loff_t)limit) {

		send_sig(SIGXFSZ, current, 0);

		goto out;

	}

	if (size > inode->i_sb->s_maxbytes)

	err = inode_newsize_ok(inode, size);

	if (err)

		goto out;



	err = pagecache_write_begin(NULL, mapping, size, 0,

CRA Git | Maintained and supported by SUSTech CRA and CCSE