Commit 2fc61f25 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'xfs-5.10-merge-2' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux 

Pull xfs updates from Darrick Wong:
 "The biggest changes are two new features for the ondisk metadata: one
  to record the sizes of the inode btrees in the AG to increase
  redundancy checks and to improve mount times; and a second new feature
  to support timestamps until the year 2486.

  We also fixed a problem where reflinking into a file that requires
  synchronous writes wouldn't actually flush the updates to disk; clean
  up a fair amount of cruft; and started fixing some bugs in the
  realtime volume code.

  Summary:

   - Clean up the buffer ioend calling path so that the retry strategy
     isn't quite so scattered everywhere.

   - Clean up m_sb_bp handling.

   - New feature: storing inode btree counts in the AGI to speed up
     certain mount time per-AG block reservation operatoins and add a
     little more metadata redundancy.

   - New feature: Widen inode timestamps and quota grace expiration
     timestamps to support dates through the year 2486.

   - Get rid of more of our custom buffer allocation API wrappers.

   - Use a proper VLA for shortform xattr structure namevals.

   - Force the log after reflinking or deduping into a file that is
     opened with O_SYNC or O_DSYNC.

   - Fix some math errors in the realtime allocator"

* tag 'xfs-5.10-merge-2' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux: (42 commits)
  xfs: ensure that fpunch, fcollapse, and finsert operations are aligned to rt extent size
  xfs: make sure the rt allocator doesn't run off the end
  xfs: Remove unneeded semicolon
  xfs: force the log after remapping a synchronous-writes file
  xfs: Convert xfs_attr_sf macros to inline functions
  xfs: Use variable-size array for nameval in xfs_attr_sf_entry
  xfs: Remove typedef xfs_attr_shortform_t
  xfs: remove typedef xfs_attr_sf_entry_t
  xfs: Remove kmem_zalloc_large()
  xfs: enable big timestamps
  xfs: trace timestamp limits
  xfs: widen ondisk quota expiration timestamps to handle y2038+
  xfs: widen ondisk inode timestamps to deal with y2038+
  xfs: redefine xfs_ictimestamp_t
  xfs: redefine xfs_timestamp_t
  xfs: move xfs_log_dinode_to_disk to the log recovery code
  xfs: refactor quota timestamp coding
  xfs: refactor default quota grace period setting code
  xfs: refactor quota expiration timer modification
  xfs: explicitly define inode timestamp range
  ...
parents 37187df4 fe341eb1

fs/xfs/kmem.c

+0 −22
Original line number Diff line number Diff line
@@ -93,25 +93,3 @@ kmem_alloc_large(size_t size, xfs_km_flags_t flags) 
		return ptr;

	return __kmem_vmalloc(size, flags);

}
 


void *

kmem_realloc(const void *old, size_t newsize, xfs_km_flags_t flags)

{

	int	retries = 0;

	gfp_t	lflags = kmem_flags_convert(flags);

	void	*ptr;



	trace_kmem_realloc(newsize, flags, _RET_IP_);



	do {

		ptr = krealloc(old, newsize, lflags);

		if (ptr || (flags & KM_MAYFAIL))

			return ptr;

		if (!(++retries % 100))

			xfs_err(NULL,

	"%s(%u) possible memory allocation deadlock size %zu in %s (mode:0x%x)",

				current->comm, current->pid,

				newsize, __func__, lflags);

		congestion_wait(BLK_RW_ASYNC, HZ/50);

	} while (1);

}

fs/xfs/kmem.h

+0 −7
Original line number Diff line number Diff line
@@ -59,7 +59,6 @@ kmem_flags_convert(xfs_km_flags_t flags) 
extern void *kmem_alloc(size_t, xfs_km_flags_t);

extern void *kmem_alloc_io(size_t size, int align_mask, xfs_km_flags_t flags);

extern void *kmem_alloc_large(size_t size, xfs_km_flags_t);

extern void *kmem_realloc(const void *, size_t, xfs_km_flags_t);

static inline void  kmem_free(const void *ptr)

{

	kvfree(ptr);
@@ -72,12 +71,6 @@ kmem_zalloc(size_t size, xfs_km_flags_t flags) 
	return kmem_alloc(size, flags | KM_ZERO);

}



static inline void *

kmem_zalloc_large(size_t size, xfs_km_flags_t flags)

{

	return kmem_alloc_large(size, flags | KM_ZERO);

}



/*

 * Zone interfaces

 */

fs/xfs/libxfs/xfs_ag.c

+5 −0
Original line number Diff line number Diff line
@@ -333,6 +333,11 @@ xfs_agiblock_init( 
	}

	for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)

		agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);

	if (xfs_sb_version_hasinobtcounts(&mp->m_sb)) {

		agi->agi_iblocks = cpu_to_be32(1);

		if (xfs_sb_version_hasfinobt(&mp->m_sb))

			agi->agi_fblocks = cpu_to_be32(1);

	}

}



typedef void (*aghdr_init_work_f)(struct xfs_mount *mp, struct xfs_buf *bp,

fs/xfs/libxfs/xfs_attr.c

+11 −3
Original line number Diff line number Diff line
@@ -428,7 +428,7 @@ xfs_attr_set( 
		 */

		if (XFS_IFORK_Q(dp) == 0) {

			int sf_size = sizeof(struct xfs_attr_sf_hdr) +

				XFS_ATTR_SF_ENTSIZE_BYNAME(args->namelen,

				xfs_attr_sf_entsize_byname(args->namelen,

						args->valuelen);



			error = xfs_bmap_add_attrfork(dp, sf_size, rsvd);
@@ -523,6 +523,14 @@ xfs_attr_set( 
 * External routines when attribute list is inside the inode

 *========================================================================*/



static inline int xfs_attr_sf_totsize(struct xfs_inode *dp)

{

	struct xfs_attr_shortform *sf;



	sf = (struct xfs_attr_shortform *)dp->i_afp->if_u1.if_data;

	return be16_to_cpu(sf->hdr.totsize);

}



/*

 * Add a name to the shortform attribute list structure

 * This is the external routine.
@@ -555,8 +563,8 @@ xfs_attr_shortform_addname(xfs_da_args_t *args) 
	    args->valuelen >= XFS_ATTR_SF_ENTSIZE_MAX)

		return -ENOSPC;



	newsize = XFS_ATTR_SF_TOTSIZE(args->dp);

	newsize += XFS_ATTR_SF_ENTSIZE_BYNAME(args->namelen, args->valuelen);

	newsize = xfs_attr_sf_totsize(args->dp);

	newsize += xfs_attr_sf_entsize_byname(args->namelen, args->valuelen);



	forkoff = xfs_attr_shortform_bytesfit(args->dp, newsize);

	if (!forkoff)

fs/xfs/libxfs/xfs_attr_leaf.c

+21 −22
Original line number Diff line number Diff line
@@ -684,9 +684,9 @@ xfs_attr_sf_findname( 
	sf = (struct xfs_attr_shortform *)args->dp->i_afp->if_u1.if_data;

	sfe = &sf->list[0];

	end = sf->hdr.count;

	for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),

	for (i = 0; i < end; sfe = xfs_attr_sf_nextentry(sfe),

			     base += size, i++) {

		size = XFS_ATTR_SF_ENTSIZE(sfe);

		size = xfs_attr_sf_entsize(sfe);

		if (!xfs_attr_match(args, sfe->namelen, sfe->nameval,

				    sfe->flags))

			continue;
@@ -728,15 +728,15 @@ xfs_attr_shortform_add( 


	ifp = dp->i_afp;

	ASSERT(ifp->if_flags & XFS_IFINLINE);

	sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;

	sf = (struct xfs_attr_shortform *)ifp->if_u1.if_data;

	if (xfs_attr_sf_findname(args, &sfe, NULL) == -EEXIST)

		ASSERT(0);



	offset = (char *)sfe - (char *)sf;

	size = XFS_ATTR_SF_ENTSIZE_BYNAME(args->namelen, args->valuelen);

	size = xfs_attr_sf_entsize_byname(args->namelen, args->valuelen);

	xfs_idata_realloc(dp, size, XFS_ATTR_FORK);

	sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;

	sfe = (xfs_attr_sf_entry_t *)((char *)sf + offset);

	sf = (struct xfs_attr_shortform *)ifp->if_u1.if_data;

	sfe = (struct xfs_attr_sf_entry *)((char *)sf + offset);



	sfe->namelen = args->namelen;

	sfe->valuelen = args->valuelen;
@@ -787,12 +787,12 @@ xfs_attr_shortform_remove( 


	dp = args->dp;

	mp = dp->i_mount;

	sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;

	sf = (struct xfs_attr_shortform *)dp->i_afp->if_u1.if_data;



	error = xfs_attr_sf_findname(args, &sfe, &base);

	if (error != -EEXIST)

		return error;

	size = XFS_ATTR_SF_ENTSIZE(sfe);

	size = xfs_attr_sf_entsize(sfe);



	/*

	 * Fix up the attribute fork data, covering the hole
@@ -837,8 +837,8 @@ xfs_attr_shortform_remove( 
int

xfs_attr_shortform_lookup(xfs_da_args_t *args)

{

	xfs_attr_shortform_t *sf;

	xfs_attr_sf_entry_t *sfe;

	struct xfs_attr_shortform *sf;

	struct xfs_attr_sf_entry *sfe;

	int i;

	struct xfs_ifork *ifp;
@@ -846,10 +846,10 @@ xfs_attr_shortform_lookup(xfs_da_args_t *args) 


	ifp = args->dp->i_afp;

	ASSERT(ifp->if_flags & XFS_IFINLINE);

	sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;

	sf = (struct xfs_attr_shortform *)ifp->if_u1.if_data;

	sfe = &sf->list[0];

	for (i = 0; i < sf->hdr.count;

				sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {

				sfe = xfs_attr_sf_nextentry(sfe), i++) {

		if (xfs_attr_match(args, sfe->namelen, sfe->nameval,

				sfe->flags))

			return -EEXIST;
@@ -873,10 +873,10 @@ xfs_attr_shortform_getvalue( 
	int			i;



	ASSERT(args->dp->i_afp->if_flags == XFS_IFINLINE);

	sf = (xfs_attr_shortform_t *)args->dp->i_afp->if_u1.if_data;

	sf = (struct xfs_attr_shortform *)args->dp->i_afp->if_u1.if_data;

	sfe = &sf->list[0];

	for (i = 0; i < sf->hdr.count;

				sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {

				sfe = xfs_attr_sf_nextentry(sfe), i++) {

		if (xfs_attr_match(args, sfe->namelen, sfe->nameval,

				sfe->flags))

			return xfs_attr_copy_value(args,
@@ -908,12 +908,12 @@ xfs_attr_shortform_to_leaf( 


	dp = args->dp;

	ifp = dp->i_afp;

	sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;

	sf = (struct xfs_attr_shortform *)ifp->if_u1.if_data;

	size = be16_to_cpu(sf->hdr.totsize);

	tmpbuffer = kmem_alloc(size, 0);

	ASSERT(tmpbuffer != NULL);

	memcpy(tmpbuffer, ifp->if_u1.if_data, size);

	sf = (xfs_attr_shortform_t *)tmpbuffer;

	sf = (struct xfs_attr_shortform *)tmpbuffer;



	xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);

	xfs_bmap_local_to_extents_empty(args->trans, dp, XFS_ATTR_FORK);
@@ -951,7 +951,7 @@ xfs_attr_shortform_to_leaf( 
		ASSERT(error != -ENOSPC);

		if (error)

			goto out;

		sfe = XFS_ATTR_SF_NEXTENTRY(sfe);

		sfe = xfs_attr_sf_nextentry(sfe);

	}

	error = 0;

	*leaf_bp = bp;
@@ -992,9 +992,8 @@ xfs_attr_shortform_allfit( 
			return 0;

		if (be16_to_cpu(name_loc->valuelen) >= XFS_ATTR_SF_ENTSIZE_MAX)

			return 0;

		bytes += sizeof(struct xfs_attr_sf_entry) - 1

				+ name_loc->namelen

				+ be16_to_cpu(name_loc->valuelen);

		bytes += xfs_attr_sf_entsize_byname(name_loc->namelen,

					be16_to_cpu(name_loc->valuelen));

	}

	if ((dp->i_mount->m_flags & XFS_MOUNT_ATTR2) &&

	    (dp->i_df.if_format != XFS_DINODE_FMT_BTREE) &&
@@ -1039,7 +1038,7 @@ xfs_attr_shortform_verify( 
		 * xfs_attr_sf_entry is defined with a 1-byte variable

		 * array at the end, so we must subtract that off.

		 */

		if (((char *)sfep + sizeof(*sfep) - 1) >= endp)

		if (((char *)sfep + sizeof(*sfep)) >= endp)

			return __this_address;



		/* Don't allow names with known bad length. */
@@ -1051,7 +1050,7 @@ xfs_attr_shortform_verify( 
		 * within the data buffer.  The next entry starts after the

		 * name component, so nextentry is an acceptable test.

		 */

		next_sfep = XFS_ATTR_SF_NEXTENTRY(sfep);

		next_sfep = xfs_attr_sf_nextentry(sfep);

		if ((char *)next_sfep > endp)

			return __this_address;