Merge tag 'ext4_for_linus_stable' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4

        system after its metadata has been committed to the journal.

  commit=nrsec	(*)

        Ext4 can be told to sync all its data and metadata every 'nrsec'

        seconds. The default value is 5 seconds.  This means that if you lose

        your power, you will lose as much as the latest 5 seconds of work (your

        filesystem will not be damaged though, thanks to the journaling).  This

        default value (or any low value) will hurt performance, but it's good

        for data-safety.  Setting it to 0 will have the same effect as leaving

        it at the default (5 seconds).  Setting it to very large values will

        improve performance.

        This setting limits the maximum age of the running transaction to

        'nrsec' seconds.  The default value is 5 seconds.  This means that if

        you lose your power, you will lose as much as the latest 5 seconds of

        metadata changes (your filesystem will not be damaged though, thanks

        to the journaling). This default value (or any low value) will hurt

        performance, but it's good for data-safety.  Setting it to 0 will have

        the same effect as leaving it at the default (5 seconds).  Setting it

        to very large values will improve performance.  Note that due to

        delayed allocation even older data can be lost on power failure since

        writeback of those data begins only after time set in

        /proc/sys/vm/dirty_expire_centisecs.

  barrier=<0|1(*)>, barrier(*), nobarrier

        This enables/disables the use of write barriers in the jbd code.

{

	struct rb_node *node;

	struct ext4_system_zone *entry;

	struct ext4_system_blocks *system_blks;

	int first = 1;

	printk(KERN_INFO "System zones: ");

	node = rb_first(&sbi->system_blks->root);

	rcu_read_lock();

	system_blks = rcu_dereference(sbi->system_blks);

	node = rb_first(&system_blks->root);

	while (node) {

		entry = rb_entry(node, struct ext4_system_zone, node);

		printk(KERN_CONT "%s%llu-%llu", first ? "" : ", ",

		first = 0;

		node = rb_next(node);

	}

	rcu_read_unlock();

	printk(KERN_CONT "\n");

}

	const char *error_msg = NULL;

	const int rlen = ext4_rec_len_from_disk(de->rec_len,

						dir->i_sb->s_blocksize);

	const int next_offset = ((char *) de - buf) + rlen;

	if (unlikely(rlen < EXT4_DIR_REC_LEN(1)))

		error_msg = "rec_len is smaller than minimal";

		error_msg = "rec_len % 4 != 0";

	else if (unlikely(rlen < EXT4_DIR_REC_LEN(de->name_len)))

		error_msg = "rec_len is too small for name_len";

	else if (unlikely(((char *) de - buf) + rlen > size))

	else if (unlikely(next_offset > size))

		error_msg = "directory entry overrun";

	else if (unlikely(next_offset > size - EXT4_DIR_REC_LEN(1) &&

			  next_offset != size))

		error_msg = "directory entry too close to block end";

	else if (unlikely(le32_to_cpu(de->inode) >

			le32_to_cpu(EXT4_SB(dir->i_sb)->s_es->s_inodes_count)))

		error_msg = "inode out of bounds";

		if (!handle) {

			BUG_ON(nblocks <= 0);

			handle = __ext4_journal_start_sb(dir->i_sb, line_no,

							 handle_type, nblocks,

							 0, 0);

				 handle_type, nblocks, 0,

				 ext4_trans_default_revoke_credits(sb));

			if (IS_ERR(handle)) {

				err = PTR_ERR(handle);

				ext4_std_error(sb, err);

	error = ext4_journal_get_write_access(handle, iloc->bh);

	if (error) {

		brelse(iloc->bh);

		goto out_stop;

		goto out_unlock;

	}

	error = __ext4_expand_extra_isize(inode, new_extra_isize, iloc,

	if (!error)

		error = rc;

out_unlock:

	ext4_write_unlock_xattr(inode, &no_expand);

out_stop:

	ext4_journal_stop(handle);

	return error;

}