Merge tag 'for-linus-v3.11-rc1-2' of git://oss.sgi.com/xfs/xfs

=============

When mounting an XFS filesystem, the following options are accepted.

For boolean mount options, the names with the (*) suffix is the

default behaviour.

  allocsize=size

	Sets the buffered I/O end-of-file preallocation size when

	Valid values for this option are page size (typically 4KiB)

	through to 1GiB, inclusive, in power-of-2 increments.

  attr2/noattr2

	The options enable/disable (default is disabled for backward

	compatibility on-disk) an "opportunistic" improvement to be

	made in the way inline extended attributes are stored on-disk.

	When the new form is used for the first time (by setting or

	removing extended attributes) the on-disk superblock feature

	bit field will be updated to reflect this format being in use.

	The default behaviour is for dynamic end-of-file

	preallocation size, which uses a set of heuristics to

	optimise the preallocation size based on the current

	allocation patterns within the file and the access patterns

	to the file. Specifying a fixed allocsize value turns off

	the dynamic behaviour.

  attr2

  noattr2

	The options enable/disable an "opportunistic" improvement to

	be made in the way inline extended attributes are stored

	on-disk.  When the new form is used for the first time when

	attr2 is selected (either when setting or removing extended

	attributes) the on-disk superblock feature bit field will be

	updated to reflect this format being in use.

	The default behaviour is determined by the on-disk feature

	bit indicating that attr2 behaviour is active. If either

	mount option it set, then that becomes the new default used

	by the filesystem.

	CRC enabled filesystems always use the attr2 format, and so

	will reject the noattr2 mount option if it is set.

  barrier

	Enables the use of block layer write barriers for writes into

	the journal and unwritten extent conversion.  This allows for

	drive level write caching to be enabled, for devices that

	support write barriers.

  barrier (*)

  nobarrier

	Enables/disables the use of block layer write barriers for

	writes into the journal and for data integrity operations.

	This allows for drive level write caching to be enabled, for

	devices that support write barriers.

  discard

	Issue command to let the block device reclaim space freed by the

	filesystem.  This is useful for SSD devices, thinly provisioned

	LUNs and virtual machine images, but may have a performance

	impact.

  dmapi

	Enable the DMAPI (Data Management API) event callouts.

	Use with the "mtpt" option.

  grpid/bsdgroups and nogrpid/sysvgroups

	These options define what group ID a newly created file gets.

	When grpid is set, it takes the group ID of the directory in

	which it is created; otherwise (the default) it takes the fsgid

	of the current process, unless the directory has the setgid bit

	set, in which case it takes the gid from the parent directory,

	and also gets the setgid bit set if it is a directory itself.

  ihashsize=value

	In memory inode hashes have been removed, so this option has

	no function as of August 2007. Option is deprecated.

  ikeep/noikeep

	When ikeep is specified, XFS does not delete empty inode clusters

	and keeps them around on disk. ikeep is the traditional XFS

	behaviour. When noikeep is specified, empty inode clusters

	are returned to the free space pool. The default is noikeep for

	non-DMAPI mounts, while ikeep is the default when DMAPI is in use.

  inode64

	Indicates that XFS is allowed to create inodes at any location

	in the filesystem, including those which will result in inode

	numbers occupying more than 32 bits of significance.  This is

	the default allocation option. Applications which do not handle

	inode numbers bigger than 32 bits, should use inode32 option.

  nodiscard (*)

	Enable/disable the issuing of commands to let the block

	device reclaim space freed by the filesystem.  This is

	useful for SSD devices, thinly provisioned LUNs and virtual

	machine images, but may have a performance impact.

	Note: It is currently recommended that you use the fstrim

	application to discard unused blocks rather than the discard

	mount option because the performance impact of this option

	is quite severe.

  grpid/bsdgroups

  nogrpid/sysvgroups (*)

	These options define what group ID a newly created file

	gets.  When grpid is set, it takes the group ID of the

	directory in which it is created; otherwise it takes the

	fsgid of the current process, unless the directory has the

	setgid bit set, in which case it takes the gid from the

	parent directory, and also gets the setgid bit set if it is

	a directory itself.

  filestreams

	Make the data allocator use the filestreams allocation mode

	across the entire filesystem rather than just on directories

	configured to use it.

  ikeep

  noikeep (*)

	When ikeep is specified, XFS does not delete empty inode

	clusters and keeps them around on disk.  When noikeep is

	specified, empty inode clusters are returned to the free

	space pool.

  inode32

	Indicates that XFS is limited to create inodes at locations which

	will not result in inode numbers with more than 32 bits of

	significance. This is provided for backwards compatibility, since

	64 bits inode numbers might cause problems for some applications

	that cannot handle large inode numbers.

  largeio/nolargeio

  inode64 (*)

	When inode32 is specified, it indicates that XFS limits

	inode creation to locations which will not result in inode

	numbers with more than 32 bits of significance.

	When inode64 is specified, it indicates that XFS is allowed

	to create inodes at any location in the filesystem,

	including those which will result in inode numbers occupying

	more than 32 bits of significance. 

	inode32 is provided for backwards compatibility with older

	systems and applications, since 64 bits inode numbers might

	cause problems for some applications that cannot handle

	large inode numbers.  If applications are in use which do

	not handle inode numbers bigger than 32 bits, the inode32

	option should be specified.

  largeio

  nolargeio (*)

	If "nolargeio" is specified, the optimal I/O reported in

	st_blksize by stat(2) will be as small as possible to allow user

	applications to avoid inefficient read/modify/write I/O.

	If "largeio" specified, a filesystem that has a "swidth" specified

	will return the "swidth" value (in bytes) in st_blksize. If the

	filesystem does not have a "swidth" specified but does specify

	an "allocsize" then "allocsize" (in bytes) will be returned

	instead.

	If neither of these two options are specified, then filesystem

	will behave as if "nolargeio" was specified.

	st_blksize by stat(2) will be as small as possible to allow

	user applications to avoid inefficient read/modify/write

	I/O.  This is typically the page size of the machine, as

	this is the granularity of the page cache.

	If "largeio" specified, a filesystem that was created with a

	"swidth" specified will return the "swidth" value (in bytes)

	in st_blksize. If the filesystem does not have a "swidth"

	specified but does specify an "allocsize" then "allocsize"

	(in bytes) will be returned instead. Otherwise the behaviour

	is the same as if "nolargeio" was specified.

  logbufs=value

	Set the number of in-memory log buffers.  Valid numbers range

	from 2-8 inclusive.

	The default value is 8 buffers for filesystems with a

	blocksize of 64KiB, 4 buffers for filesystems with a blocksize

	of 32KiB, 3 buffers for filesystems with a blocksize of 16KiB

	and 2 buffers for all other configurations.  Increasing the

	number of buffers may increase performance on some workloads

	at the cost of the memory used for the additional log buffers

	and their associated control structures.

	Set the number of in-memory log buffers.  Valid numbers

	range from 2-8 inclusive.

	The default value is 8 buffers.

	If the memory cost of 8 log buffers is too high on small

	systems, then it may be reduced at some cost to performance

	on metadata intensive workloads. The logbsize option below

	controls the size of each buffer and so is also relevent to

	this case.

  logbsize=value

	Set the size of each in-memory log buffer.

	Size may be specified in bytes, or in kilobytes with a "k" suffix.

	Valid sizes for version 1 and version 2 logs are 16384 (16k) and

	32768 (32k).  Valid sizes for version 2 logs also include

	65536 (64k), 131072 (128k) and 262144 (256k).

	The default value for machines with more than 32MiB of memory

	is 32768, machines with less memory use 16384 by default.

	Set the size of each in-memory log buffer.  The size may be

	specified in bytes, or in kilobytes with a "k" suffix.

	Valid sizes for version 1 and version 2 logs are 16384 (16k)

	and 32768 (32k).  Valid sizes for version 2 logs also

	include 65536 (64k), 131072 (128k) and 262144 (256k). The

	logbsize must be an integer multiple of the log

	stripe unit configured at mkfs time.

	The default value for for version 1 logs is 32768, while the

	default value for version 2 logs is MAX(32768, log_sunit).

  logdev=device and rtdev=device

	Use an external log (metadata journal) and/or real-time device.

	optional, and the log section can be separate from the data

	section or contained within it.

  mtpt=mountpoint

	Use with the "dmapi" option.  The value specified here will be

	included in the DMAPI mount event, and should be the path of

	the actual mountpoint that is used.

  noalign

	Data allocations will not be aligned at stripe unit boundaries.

  noatime

	Access timestamps are not updated when a file is read.

	Data allocations will not be aligned at stripe unit

	boundaries. This is only relevant to filesystems created

	with non-zero data alignment parameters (sunit, swidth) by

	mkfs.

  norecovery

	The filesystem will be mounted without running log recovery.

	the mount will fail.

  nouuid

	Don't check for double mounted file systems using the file system uuid.

	This is useful to mount LVM snapshot volumes.

	Don't check for double mounted file systems using the file

	system uuid.  This is useful to mount LVM snapshot volumes,

	and often used in combination with "norecovery" for mounting

	read-only snapshots.

  noquota

	Forcibly turns off all quota accounting and enforcement

	within the filesystem.

  uquota/usrquota/uqnoenforce/quota

	User disk quota accounting enabled, and limits (optionally)

	enforced.  Refer to xfs_quota(8) for further details.

  sunit=value and swidth=value

	Used to specify the stripe unit and width for a RAID device or

	a stripe volume.  "value" must be specified in 512-byte block

	units.

	If this option is not specified and the filesystem was made on

	a stripe volume or the stripe width or unit were specified for

	the RAID device at mkfs time, then the mount system call will

	restore the value from the superblock.  For filesystems that

	are made directly on RAID devices, these options can be used

	to override the information in the superblock if the underlying

	disk layout changes after the filesystem has been created.

	The "swidth" option is required if the "sunit" option has been

	specified, and must be a multiple of the "sunit" value.

	Used to specify the stripe unit and width for a RAID device

	or a stripe volume.  "value" must be specified in 512-byte

	block units. These options are only relevant to filesystems

	that were created with non-zero data alignment parameters.

	The sunit and swidth parameters specified must be compatible

	with the existing filesystem alignment characteristics.  In

	general, that means the only valid changes to sunit are

	increasing it by a power-of-2 multiple. Valid swidth values

	are any integer multiple of a valid sunit value.

	Typically the only time these mount options are necessary if

	after an underlying RAID device has had it's geometry

	modified, such as adding a new disk to a RAID5 lun and

	reshaping it.

  swalloc

	Data allocations will be rounded up to stripe width boundaries

	when the current end of file is being extended and the file

	size is larger than the stripe width size.

  wsync

	When specified, all filesystem namespace operations are

	executed synchronously. This ensures that when the namespace

	operation (create, unlink, etc) completes, the change to the

	namespace is on stable storage. This is useful in HA setups

	where failover must not result in clients seeing

	inconsistent namespace presentation during or after a

	failover event.

Deprecated Mount Options

========================

  delaylog/nodelaylog

	Delayed logging is the only logging method that XFS supports

	now, so these mount options are now ignored.

	Due for removal in 3.12.

  ihashsize=value

	In memory inode hashes have been removed, so this option has

	no function as of August 2007. Option is deprecated.

	Due for removal in 3.12.

  irixsgid

	This behaviour is now controlled by a sysctl, so the mount

	option is ignored.

	Due for removal in 3.12.

  osyncisdsync

  osyncisosync

	O_SYNC and O_DSYNC are fully supported, so there is no need

	for these options any more.

	Due for removal in 3.12.

sysctls

=======

	in /proc/fs/xfs/stat.  It then immediately resets to "0".

  fs.xfs.xfssyncd_centisecs	(Min: 100  Default: 3000  Max: 720000)

  	The interval at which the xfssyncd thread flushes metadata

  	out to disk.  This thread will flush log activity out, and

  	do some processing on unlinked inodes.

	The interval at which the filesystem flushes metadata

	out to disk and runs internal cache cleanup routines.

  fs.xfs.xfsbufd_centisecs	(Min: 50  Default: 100	Max: 3000)

	The interval at which xfsbufd scans the dirty metadata buffers list.

  fs.xfs.filestream_centisecs	(Min: 1  Default: 3000  Max: 360000)

	The interval at which the filesystem ages filestreams cache

	references and returns timed-out AGs back to the free stream

	pool.

  fs.xfs.age_buffer_centisecs	(Min: 100  Default: 1500  Max: 720000)

	The age at which xfsbufd flushes dirty metadata buffers to disk.

  fs.xfs.speculative_prealloc_lifetime

		(Units: seconds   Min: 1  Default: 300  Max: 86400)

	The interval at which the background scanning for inodes

	with unused speculative preallocation runs. The scan

	removes unused preallocation from clean inodes and releases

	the unused space back to the free pool.

  fs.xfs.error_level		(Min: 0  Default: 3  Max: 11)

	A volume knob for error reporting when internal errors occur.

	by the xfs_io(8) chattr command on a directory to be

	inherited by files in that directory.

  fs.xfs.inherit_nodefrag	(Min: 0  Default: 1  Max: 1)

	Setting this to "1" will cause the "nodefrag" flag set

	by the xfs_io(8) chattr command on a directory to be

	inherited by files in that directory.

  fs.xfs.rotorstep		(Min: 1  Default: 1  Max: 256)

	In "inode32" allocation mode, this option determines how many

	files the allocator attempts to allocate in the same allocation

	group before moving to the next allocation group.  The intent

	is to control the rate at which the allocator moves between

	allocation groups when allocating extents for new files.

Deprecated Sysctls

==================

  fs.xfs.xfsbufd_centisecs	(Min: 50  Default: 100	Max: 3000)

	Dirty metadata is now tracked by the log subsystem and

	flushing is driven by log space and idling demands. The

	xfsbufd no longer exists, so this syctl does nothing.

	Due for removal in 3.14.

  fs.xfs.age_buffer_centisecs	(Min: 100  Default: 1500  Max: 720000)

	Dirty metadata is now tracked by the log subsystem and

	flushing is driven by log space and idling demands. The

	xfsbufd no longer exists, so this syctl does nothing.

	Due for removal in 3.14.

	sf = (xfs_attr_shortform_t *)tmpbuffer;

	xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);

	xfs_bmap_local_to_extents_empty(dp, XFS_ATTR_FORK);

	bp = NULL;

	error = xfs_da_grow_inode(args, &blkno);

	if (error) {

 * since the file data needs to get logged so things will stay consistent.

 * (The bmap-level manipulations are ok, though).

 */

void

xfs_bmap_local_to_extents_empty(

	struct xfs_inode	*ip,

	int			whichfork)

{

	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, whichfork);

	ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL);

	ASSERT(ifp->if_bytes == 0);

	ASSERT(XFS_IFORK_NEXTENTS(ip, whichfork) == 0);

	xfs_bmap_forkoff_reset(ip->i_mount, ip, whichfork);

	ifp->if_flags &= ~XFS_IFINLINE;

	ifp->if_flags |= XFS_IFEXTENTS;

	XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS);

}

STATIC int				/* error */

xfs_bmap_local_to_extents(

	xfs_trans_t	*tp,		/* transaction pointer */

				   struct xfs_inode *ip,

				   struct xfs_ifork *ifp))

{

	int		error;		/* error return value */

	int		error = 0;

	int		flags;		/* logging flags returned */

	xfs_ifork_t	*ifp;		/* inode fork pointer */

	xfs_alloc_arg_t	args;		/* allocation arguments */

	xfs_buf_t	*bp;		/* buffer for extent block */

	xfs_bmbt_rec_host_t *ep;	/* extent record pointer */

	/*

	 * We don't want to deal with the case of keeping inode data inline yet.

	ASSERT(!(S_ISREG(ip->i_d.di_mode) && whichfork == XFS_DATA_FORK));

	ifp = XFS_IFORK_PTR(ip, whichfork);

	ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL);

	if (!ifp->if_bytes) {

		xfs_bmap_local_to_extents_empty(ip, whichfork);

		flags = XFS_ILOG_CORE;

		goto done;

	}

	flags = 0;

	error = 0;

	if (ifp->if_bytes) {

		xfs_alloc_arg_t	args;	/* allocation arguments */

		xfs_buf_t	*bp;	/* buffer for extent block */

		xfs_bmbt_rec_host_t *ep;/* extent record pointer */

		ASSERT((ifp->if_flags &

			(XFS_IFINLINE|XFS_IFEXTENTS|XFS_IFEXTIREC)) == XFS_IFINLINE);

	ASSERT((ifp->if_flags & (XFS_IFINLINE|XFS_IFEXTENTS|XFS_IFEXTIREC)) ==

								XFS_IFINLINE);

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

	args.tp = tp;

	args.mp = ip->i_mount;

	/* account for the change in fork size and log everything */

	xfs_trans_log_buf(tp, bp, 0, ifp->if_bytes - 1);

		xfs_bmap_forkoff_reset(args.mp, ip, whichfork);

	xfs_idata_realloc(ip, -ifp->if_bytes, whichfork);

	xfs_bmap_local_to_extents_empty(ip, whichfork);

	flags |= XFS_ILOG_CORE;

	xfs_iext_add(ifp, 0, 1);

	ep = xfs_iext_get_ext(ifp, 0);

	xfs_bmbt_set_allf(ep, 0, args.fsbno, 1, XFS_EXT_NORM);

	xfs_trans_mod_dquot_byino(tp, ip,

		XFS_TRANS_DQ_BCOUNT, 1L);

	flags |= xfs_ilog_fext(whichfork);

	} else {

		ASSERT(XFS_IFORK_NEXTENTS(ip, whichfork) == 0);

		xfs_bmap_forkoff_reset(ip->i_mount, ip, whichfork);

	}

	ifp->if_flags &= ~XFS_IFINLINE;

	ifp->if_flags |= XFS_IFEXTENTS;

	XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS);

	flags |= XFS_ILOG_CORE;

done:

	*logflagsp = flags;

	return error;

	return error;

}

/*

 * Block initialisation function for local to extent format conversion.

 *

 * This shouldn't actually be called by anyone, so make sure debug kernels cause

 * a noticable failure.

 */

STATIC void

xfs_bmap_local_to_extents_init_fn(

	struct xfs_trans	*tp,

	struct xfs_buf		*bp,

	struct xfs_inode	*ip,

	struct xfs_ifork	*ifp)

{

	ASSERT(0);

	bp->b_ops = &xfs_bmbt_buf_ops;

	memcpy(bp->b_addr, ifp->if_u1.if_data, ifp->if_bytes);

	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_BTREE_BUF);

}

/*

 * Called from xfs_bmap_add_attrfork to handle local format files. Each

 * different data fork content type needs a different callout to do the

						 flags, XFS_DATA_FORK,

						 xfs_symlink_local_to_remote);

	return xfs_bmap_local_to_extents(tp, ip, firstblock, 1, flags,

					 XFS_DATA_FORK,

					 xfs_bmap_local_to_extents_init_fn);

	/* should only be called for types that support local format data */

	ASSERT(0);

	return EFSCORRUPTED;

}

/*

	orig_mval = mval;

	orig_nmap = *nmap;

#endif

	whichfork = (flags & XFS_BMAPI_ATTRFORK) ?

		XFS_ATTR_FORK : XFS_DATA_FORK;

	ASSERT(*nmap >= 1);

	ASSERT(*nmap <= XFS_BMAP_MAX_NMAP);

	ASSERT(!(flags & XFS_BMAPI_IGSTATE));

	ASSERT(tp != NULL);

	ASSERT(len > 0);

	whichfork = (flags & XFS_BMAPI_ATTRFORK) ?

		XFS_ATTR_FORK : XFS_DATA_FORK;

	ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL);

	if (unlikely(XFS_TEST_ERROR(

	    (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&

	     XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE &&

	     XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL),

	     XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),

	     mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {

		XFS_ERROR_REPORT("xfs_bmapi_write", XFS_ERRLEVEL_LOW, mp);

		return XFS_ERROR(EFSCORRUPTED);

	XFS_STATS_INC(xs_blk_mapw);

	if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) {

		/*

		 * XXX (dgc): This assumes we are only called for inodes that

		 * contain content neutral data in local format. Anything that

		 * contains caller-specific data in local format that needs

		 * transformation to move to a block format needs to do the

		 * conversion to extent format itself.

		 *

		 * Directory data forks and attribute forks handle this

		 * themselves, but with the addition of metadata verifiers every

		 * data fork in local format now contains caller specific data

		 * and as such conversion through this function is likely to be

		 * broken.

		 *

		 * The only likely user of this branch is for remote symlinks,

		 * but we cannot overwrite the data fork contents of the symlink

		 * (EEXIST occurs higher up the stack) and so it will never go

		 * from local format to extent format here. Hence I don't think

		 * this branch is ever executed intentionally and we should

		 * consider removing it and asserting that xfs_bmapi_write()

		 * cannot be called directly on local format forks. i.e. callers

		 * are completely responsible for local to extent format

		 * conversion, not xfs_bmapi_write().

		 */

		error = xfs_bmap_local_to_extents(tp, ip, firstblock, total,

					&bma.logflags, whichfork,

					xfs_bmap_local_to_extents_init_fn);

		if (error)

			goto error0;

	}

	if (*firstblock == NULLFSBLOCK) {

		if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE)

			bma.minleft = be16_to_cpu(ifp->if_broot->bb_level) + 1;

#endif

int	xfs_bmap_add_attrfork(struct xfs_inode *ip, int size, int rsvd);

void	xfs_bmap_local_to_extents_empty(struct xfs_inode *ip, int whichfork);

void	xfs_bmap_add_free(xfs_fsblock_t bno, xfs_filblks_t len,

		struct xfs_bmap_free *flist, struct xfs_mount *mp);

void	xfs_bmap_cancel(struct xfs_bmap_free *flist);

#define XFS_LITINO(mp, version) \

	((int)(((mp)->m_sb.sb_inodesize) - xfs_dinode_size(version)))

#define XFS_BROOT_SIZE_ADJ(ip) \

	(XFS_BMBT_BLOCK_LEN((ip)->i_mount) - sizeof(xfs_bmdr_block_t))

/*

 * Inode data & attribute fork sizes, per inode.

 */