[XFS] Implement the di_extsize allocator hint for non-realtime files as (dd9f438e) · Commits · e / devices / android_kernel_fairphone_FP3

fs/xfs/xfs_bmap.c

+231 −142

Original line number	Diff line number	Diff line
		@@ -2146,90 +2146,79 @@ xfs_bmap_add_extent_hole_real(
		return 0; /* keep gcc quite */
		}

		#define XFS_ALLOC_GAP_UNITS 4

		/*
		* xfs_bmap_alloc is called by xfs_bmapi to allocate an extent for a file.
		* It figures out where to ask the underlying allocator to put the new extent.
		* Adjust the size of the new extent based on di_extsize and rt extsize.
		*/
		STATIC int /* error */
		xfs_bmap_alloc(
		xfs_bmalloca_t ap) / bmap alloc argument struct */
		STATIC int
		xfs_bmap_extsize_align(
		xfs_mount_t *mp,
		xfs_bmbt_irec_t gotp, / next extent pointer */
		xfs_bmbt_irec_t prevp, / previous extent pointer */
		xfs_extlen_t extsz, /* align to this extent size */
		int rt, /* is this a realtime inode? */
		int eof, /* is extent at end-of-file? */
		int delay, /* creating delalloc extent? */
		int convert, /* overwriting unwritten extent? */
		xfs_fileoff_t offp, / in/out: aligned offset */
		xfs_extlen_t lenp) / in/out: aligned length */
		{
		xfs_fsblock_t adjust; /* adjustment to block numbers */
		xfs_alloctype_t atype=0; /* type for allocation routines */
		int error; /* error return value */
		xfs_agnumber_t fb_agno; /* ag number of ap->firstblock */
		xfs_mount_t mp; / mount point structure */
		int nullfb; /* true if ap->firstblock isn't set */
		int rt; /* true if inode is realtime */
		#ifdef __KERNEL__
		xfs_extlen_t prod=0; /* product factor for allocators */
		xfs_extlen_t ralen=0; /* realtime allocation length */
		#endif

		#define ISVALID(x,y) \
		(rt ? \
		(x) < mp->m_sb.sb_rblocks : \
		XFS_FSB_TO_AGNO(mp, x) == XFS_FSB_TO_AGNO(mp, y) && \
		XFS_FSB_TO_AGNO(mp, x) < mp->m_sb.sb_agcount && \
		XFS_FSB_TO_AGBNO(mp, x) < mp->m_sb.sb_agblocks)

		/*
		* Set up variables.
		*/
		mp = ap->ip->i_mount;
		nullfb = ap->firstblock == NULLFSBLOCK;
		rt = XFS_IS_REALTIME_INODE(ap->ip) && ap->userdata;
		fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, ap->firstblock);
		#ifdef __KERNEL__
		if (rt) {
		xfs_extlen_t extsz; /* file extent size for rt */
		xfs_fileoff_t nexto; /* next file offset */
		xfs_extlen_t orig_alen; /* original ap->alen */
		xfs_fileoff_t orig_off; /* original offset */
		xfs_extlen_t orig_alen; /* original length */
		xfs_fileoff_t orig_end; /* original off+len */
		xfs_fileoff_t orig_off; /* original ap->off */
		xfs_extlen_t mod_off; /* modulus calculations */
		xfs_fileoff_t nexto; /* next file offset */
		xfs_fileoff_t prevo; /* previous file offset */
		xfs_rtblock_t rtx; /* realtime extent number */
		xfs_extlen_t temp; /* temp for rt calculations */
		xfs_fileoff_t align_off; /* temp for offset */
		xfs_extlen_t align_alen; /* temp for length */
		xfs_extlen_t temp; /* temp for calculations */

		if (convert)
		return 0;

		orig_off = align_off = *offp;
		orig_alen = align_alen = *lenp;
		orig_end = orig_off + orig_alen;

		/*
		* Set prod to match the realtime extent size.
		* If this request overlaps an existing extent, then don't
		* attempt to perform any additional alignment.
		*/
		if (!(extsz = ap->ip->i_d.di_extsize))
		extsz = mp->m_sb.sb_rextsize;
		prod = extsz / mp->m_sb.sb_rextsize;
		orig_off = ap->off;
		orig_alen = ap->alen;
		orig_end = orig_off + orig_alen;
		if (!delay && !eof &&
		(orig_off >= gotp->br_startoff) &&
		(orig_end <= gotp->br_startoff + gotp->br_blockcount)) {
		return 0;
		}

		/*
		* If the file offset is unaligned vs. the extent size
		* we need to align it. This will be possible unless
		* the file was previously written with a kernel that didn't
		* perform this alignment.
		* perform this alignment, or if a truncate shot us in the
		* foot.
		*/
		mod_off = do_mod(orig_off, extsz);
		if (mod_off) {
		ap->alen += mod_off;
		ap->off -= mod_off;
		temp = do_mod(orig_off, extsz);
		if (temp) {
		align_alen += temp;
		align_off -= temp;
		}
		/*
		* Same adjustment for the end of the requested area.
		*/
		if ((temp = (ap->alen % extsz)))
		ap->alen += extsz - temp;
		if ((temp = (align_alen % extsz))) {
		align_alen += extsz - temp;
		}
		/*
		* If the previous block overlaps with this proposed allocation
		* then move the start forward without adjusting the length.
		*/
		prevo =
		ap->prevp->br_startoff == NULLFILEOFF ?
		0 :
		(ap->prevp->br_startoff +
		ap->prevp->br_blockcount);
		if (ap->off != orig_off && ap->off < prevo)
		ap->off = prevo;
		if (prevp->br_startoff != NULLFILEOFF) {
		if (prevp->br_startblock == HOLESTARTBLOCK)
		prevo = prevp->br_startoff;
		else
		prevo = prevp->br_startoff + prevp->br_blockcount;
		} else
		prevo = 0;
		if (align_off != orig_off && align_off < prevo)
		align_off = prevo;
		/*
		* If the next block overlaps with this proposed allocation
		* then move the start back without adjusting the length,
		@@ -2238,69 +2227,143 @@ xfs_bmap_alloc(
		* and if we hit the offset 0 limit then the next block
		* can still overlap too.
		*/
		nexto = (ap->eof \|\| ap->gotp->br_startoff == NULLFILEOFF) ?
		NULLFILEOFF : ap->gotp->br_startoff;
		if (!ap->eof &&
		ap->off + ap->alen != orig_end &&
		ap->off + ap->alen > nexto)
		ap->off = nexto > ap->alen ? nexto - ap->alen : 0;
		if (!eof && gotp->br_startoff != NULLFILEOFF) {
		if ((delay && gotp->br_startblock == HOLESTARTBLOCK) \|\|
		(!delay && gotp->br_startblock == DELAYSTARTBLOCK))
		nexto = gotp->br_startoff + gotp->br_blockcount;
		else
		nexto = gotp->br_startoff;
		} else
		nexto = NULLFILEOFF;
		if (!eof &&
		align_off + align_alen != orig_end &&
		align_off + align_alen > nexto)
		align_off = nexto > align_alen ? nexto - align_alen : 0;
		/*
		* If we're now overlapping the next or previous extent that
		* means we can't fit an extsz piece in this hole. Just move
		* the start forward to the first valid spot and set
		* the length so we hit the end.
		*/
		if ((ap->off != orig_off && ap->off < prevo) \|\|
		(ap->off + ap->alen != orig_end &&
		ap->off + ap->alen > nexto)) {
		ap->off = prevo;
		ap->alen = nexto - prevo;
		if (align_off != orig_off && align_off < prevo)
		align_off = prevo;
		if (align_off + align_alen != orig_end &&
		align_off + align_alen > nexto &&
		nexto != NULLFILEOFF) {
		ASSERT(nexto > prevo);
		align_alen = nexto - align_off;
		}

		/*
		* If the result isn't a multiple of rtextents we need to
		* remove blocks until it is.
		* If realtime, and the result isn't a multiple of the realtime
		* extent size we need to remove blocks until it is.
		*/
		if ((temp = (ap->alen % mp->m_sb.sb_rextsize))) {
		if (rt && (temp = (align_alen % mp->m_sb.sb_rextsize))) {
		/*
		* We're not covering the original request, or
		* we won't be able to once we fix the length.
		*/
		if (orig_off < ap->off \|\|
		orig_end > ap->off + ap->alen \|\|
		ap->alen - temp < orig_alen)
		if (orig_off < align_off \|\|
		orig_end > align_off + align_alen \|\|
		align_alen - temp < orig_alen)
		return XFS_ERROR(EINVAL);
		/*
		* Try to fix it by moving the start up.
		*/
		if (ap->off + temp <= orig_off) {
		ap->alen -= temp;
		ap->off += temp;
		if (align_off + temp <= orig_off) {
		align_alen -= temp;
		align_off += temp;
		}
		/*
		* Try to fix it by moving the end in.
		*/
		else if (ap->off + ap->alen - temp >= orig_end)
		ap->alen -= temp;
		else if (align_off + align_alen - temp >= orig_end)
		align_alen -= temp;
		/*
		* Set the start to the minimum then trim the length.
		*/
		else {
		ap->alen -= orig_off - ap->off;
		ap->off = orig_off;
		ap->alen -= ap->alen % mp->m_sb.sb_rextsize;
		align_alen -= orig_off - align_off;
		align_off = orig_off;
		align_alen -= align_alen % mp->m_sb.sb_rextsize;
		}
		/*
		* Result doesn't cover the request, fail it.
		*/
		if (orig_off < ap->off \|\| orig_end > ap->off + ap->alen)
		if (orig_off < align_off \|\| orig_end > align_off + align_alen)
		return XFS_ERROR(EINVAL);
		} else {
		ASSERT(orig_off >= align_off);
		ASSERT(orig_end <= align_off + align_alen);
		}

		#ifdef DEBUG
		if (!eof && gotp->br_startoff != NULLFILEOFF)
		ASSERT(align_off + align_alen <= gotp->br_startoff);
		if (prevp->br_startoff != NULLFILEOFF)
		ASSERT(align_off >= prevp->br_startoff + prevp->br_blockcount);
		#endif

		*lenp = align_alen;
		*offp = align_off;
		return 0;
		}

		#define XFS_ALLOC_GAP_UNITS 4

		/*
		* xfs_bmap_alloc is called by xfs_bmapi to allocate an extent for a file.
		* It figures out where to ask the underlying allocator to put the new extent.
		*/
		STATIC int
		xfs_bmap_alloc(
		xfs_bmalloca_t ap) / bmap alloc argument struct */
		{
		xfs_fsblock_t adjust; /* adjustment to block numbers */
		xfs_alloctype_t atype=0; /* type for allocation routines */
		int error; /* error return value */
		xfs_agnumber_t fb_agno; /* ag number of ap->firstblock */
		xfs_mount_t mp; / mount point structure */
		int nullfb; /* true if ap->firstblock isn't set */
		int rt; /* true if inode is realtime */
		xfs_extlen_t prod = 0; /* product factor for allocators */
		xfs_extlen_t ralen = 0; /* realtime allocation length */
		xfs_extlen_t align; /* minimum allocation alignment */
		xfs_rtblock_t rtx;

		#define ISVALID(x,y) \
		(rt ? \
		(x) < mp->m_sb.sb_rblocks : \
		XFS_FSB_TO_AGNO(mp, x) == XFS_FSB_TO_AGNO(mp, y) && \
		XFS_FSB_TO_AGNO(mp, x) < mp->m_sb.sb_agcount && \
		XFS_FSB_TO_AGBNO(mp, x) < mp->m_sb.sb_agblocks)

		/*
		* Set up variables.
		*/
		mp = ap->ip->i_mount;
		nullfb = ap->firstblock == NULLFSBLOCK;
		rt = XFS_IS_REALTIME_INODE(ap->ip) && ap->userdata;
		fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, ap->firstblock);
		if (rt) {
		align = ap->ip->i_d.di_extsize ?
		ap->ip->i_d.di_extsize : mp->m_sb.sb_rextsize;
		/* Set prod to match the extent size */
		prod = align / mp->m_sb.sb_rextsize;

		error = xfs_bmap_extsize_align(mp, ap->gotp, ap->prevp,
		align, rt, ap->eof, 0,
		ap->conv, &ap->off, &ap->alen);
		if (error)
		return error;
		ASSERT(ap->alen);
		ASSERT(ap->alen % mp->m_sb.sb_rextsize == 0);

		/*
		* If the offset & length are not perfectly aligned
		* then kill prod, it will just get us in trouble.
		*/
		if (do_mod(ap->off, extsz) \|\| ap->alen % extsz)
		if (do_mod(ap->off, align) \|\| ap->alen % align)
		prod = 1;
		/*
		* Set ralen to be the actual requested length in rtextents.
		@@ -2326,15 +2389,24 @@ xfs_bmap_alloc(
		ap->rval = rtx * mp->m_sb.sb_rextsize;
		} else
		ap->rval = 0;
		}
		#else
		if (rt)
		ap->rval = 0;
		#endif /* __KERNEL__ */
		else if (nullfb)
		} else {
		align = (ap->userdata && ap->ip->i_d.di_extsize &&
		(ap->ip->i_d.di_flags & XFS_DIFLAG_EXTSIZE)) ?
		ap->ip->i_d.di_extsize : 0;
		if (unlikely(align)) {
		error = xfs_bmap_extsize_align(mp, ap->gotp, ap->prevp,
		align, rt,
		ap->eof, 0, ap->conv,
		&ap->off, &ap->alen);
		ASSERT(!error);
		ASSERT(ap->alen);
		}
		if (nullfb)
		ap->rval = XFS_INO_TO_FSB(mp, ap->ip->i_ino);
		else
		ap->rval = ap->firstblock;
		}

		/*
		* If allocating at eof, and there's a previous real block,
		* try to use it's last block as our starting point.
		@@ -2598,11 +2670,12 @@ xfs_bmap_alloc(
		args.total = ap->total;
		args.minlen = ap->minlen;
		}
		if (ap->ip->i_d.di_extsize) {
		if (unlikely(ap->userdata && ap->ip->i_d.di_extsize &&
		(ap->ip->i_d.di_flags & XFS_DIFLAG_EXTSIZE))) {
		args.prod = ap->ip->i_d.di_extsize;
		if ((args.mod = (xfs_extlen_t)do_mod(ap->off, args.prod)))
		args.mod = (xfs_extlen_t)(args.prod - args.mod);
		} else if (mp->m_sb.sb_blocksize >= NBPP) {
		} else if (unlikely(mp->m_sb.sb_blocksize >= NBPP)) {
		args.prod = 1;
		args.mod = 0;
		} else {
		@@ -4590,6 +4663,7 @@ xfs_bmapi(
		char contig; /* allocation must be one extent */
		char delay; /* this request is for delayed alloc */
		char exact; /* don't do all of wasdelayed extent */
		char convert; /* unwritten extent I/O completion */
		xfs_bmbt_rec_t ep; / extent list entry pointer */
		int error; /* error return */
		xfs_bmbt_irec_t got; /* current extent list record */
		@@ -4643,7 +4717,7 @@ xfs_bmapi(
		}
		if (XFS_FORCED_SHUTDOWN(mp))
		return XFS_ERROR(EIO);
		rt = XFS_IS_REALTIME_INODE(ip);
		rt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip);
		ifp = XFS_IFORK_PTR(ip, whichfork);
		ASSERT(ifp->if_ext_max ==
		XFS_IFORK_SIZE(ip, whichfork) / (uint)sizeof(xfs_bmbt_rec_t));
		@@ -4654,6 +4728,7 @@ xfs_bmapi(
		delay = (flags & XFS_BMAPI_DELAY) != 0;
		trim = (flags & XFS_BMAPI_ENTIRE) == 0;
		userdata = (flags & XFS_BMAPI_METADATA) == 0;
		convert = (flags & XFS_BMAPI_CONVERT) != 0;
		exact = (flags & XFS_BMAPI_EXACT) != 0;
		rsvd = (flags & XFS_BMAPI_RSVBLOCKS) != 0;
		contig = (flags & XFS_BMAPI_CONTIG) != 0;
		@@ -4748,16 +4823,26 @@ xfs_bmapi(
		}
		minlen = contig ? alen : 1;
		if (delay) {
		xfs_extlen_t extsz = 0;
		xfs_extlen_t extsz;

		/* Figure out the extent size, adjust alen */
		if (rt) {
		if (!(extsz = ip->i_d.di_extsize))
		extsz = mp->m_sb.sb_rextsize;
		alen = roundup(alen, extsz);
		extsz = alen / mp->m_sb.sb_rextsize;
		} else {
		extsz = ip->i_d.di_extsize;
		}
		if (extsz) {
		error = xfs_bmap_extsize_align(mp,
		&got, &prev, extsz,
		rt, eof, delay, convert,
		&aoff, &alen);
		ASSERT(!error);
		}

		if (rt)
		extsz = alen / mp->m_sb.sb_rextsize;

		/*
		* Make a transaction-less quota reservation for
		* delayed allocation blocks. This number gets
		@@ -4785,14 +4870,15 @@ xfs_bmapi(
		xfs_bmap_worst_indlen(ip, alen);
		ASSERT(indlen > 0);

		if (rt)
		if (rt) {
		error = xfs_mod_incore_sb(mp,
		XFS_SBS_FREXTENTS,
		-(extsz), rsvd);
		else
		} else {
		error = xfs_mod_incore_sb(mp,
		XFS_SBS_FDBLOCKS,
		-(alen), rsvd);
		}
		if (!error) {
		error = xfs_mod_incore_sb(mp,
		XFS_SBS_FDBLOCKS,
		@@ -4811,6 +4897,7 @@ xfs_bmapi(
		if (error) {
		if (XFS_IS_QUOTA_ON(ip->i_mount))
		/* unreserve the blocks now */
		(void)
		XFS_TRANS_UNRESERVE_QUOTA_NBLKS(
		mp, NULL, ip,
		(long)alen, 0, rt ?
		@@ -4849,6 +4936,7 @@ xfs_bmapi(
		bma.firstblock = *firstblock;
		bma.alen = alen;
		bma.off = aoff;
		bma.conv = convert;
		bma.wasdel = wasdelay;
		bma.minlen = minlen;
		bma.low = flist->xbf_low;
		@@ -5270,8 +5358,7 @@ xfs_bunmapi(
		return 0;
		}
		XFS_STATS_INC(xs_blk_unmap);
		isrt = (whichfork == XFS_DATA_FORK) &&
		(ip->i_d.di_flags & XFS_DIFLAG_REALTIME);
		isrt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip);
		start = bno;
		bno = start + len - 1;
		ep = xfs_bmap_search_extents(ip, bno, whichfork, &eof, &lastx, &got,
		@@ -5443,7 +5530,7 @@ xfs_bunmapi(
		}
		if (wasdel) {
		ASSERT(STARTBLOCKVAL(del.br_startblock) > 0);
		/* Update realtim/data freespace, unreserve quota */
		/* Update realtime/data freespace, unreserve quota */
		if (isrt) {
		xfs_filblks_t rtexts;

		@@ -5451,14 +5538,14 @@ xfs_bunmapi(
		do_div(rtexts, mp->m_sb.sb_rextsize);
		xfs_mod_incore_sb(mp, XFS_SBS_FREXTENTS,
		(int)rtexts, rsvd);
		XFS_TRANS_RESERVE_QUOTA_NBLKS(mp, NULL, ip,
		-((long)del.br_blockcount), 0,
		(void)XFS_TRANS_RESERVE_QUOTA_NBLKS(mp,
		NULL, ip, -((long)del.br_blockcount), 0,
		XFS_QMOPT_RES_RTBLKS);
		} else {
		xfs_mod_incore_sb(mp, XFS_SBS_FDBLOCKS,
		(int)del.br_blockcount, rsvd);
		XFS_TRANS_RESERVE_QUOTA_NBLKS(mp, NULL, ip,
		-((long)del.br_blockcount), 0,
		(void)XFS_TRANS_RESERVE_QUOTA_NBLKS(mp,
		NULL, ip, -((long)del.br_blockcount), 0,
		XFS_QMOPT_RES_REGBLKS);
		}
		ip->i_delayed_blks -= del.br_blockcount;
		@@ -5652,7 +5739,9 @@ xfs_getbmap(
		ip->i_d.di_format != XFS_DINODE_FMT_LOCAL)
		return XFS_ERROR(EINVAL);
		if (whichfork == XFS_DATA_FORK) {
		if (ip->i_d.di_flags & XFS_DIFLAG_PREALLOC) {
		if ((ip->i_d.di_extsize && (ip->i_d.di_flags &
		(XFS_DIFLAG_REALTIME\|XFS_DIFLAG_EXTSIZE))) \|\|
		ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC\|XFS_DIFLAG_APPEND)){
		prealloced = 1;
		fixlen = XFS_MAXIOFFSET(mp);
		} else {

fs/xfs/xfs_bmap.h

+6 −1

Original line number	Diff line number	Diff line
		@@ -62,6 +62,10 @@ typedef struct xfs_bmap_free
		#define XFS_BMAPI_IGSTATE 0x200 /* Ignore state - */
		/* combine contig. space */
		#define XFS_BMAPI_CONTIG 0x400 /* must allocate only one extent */
		/* XFS_BMAPI_DIRECT_IO 0x800 */
		#define XFS_BMAPI_CONVERT 0x1000 /* unwritten extent conversion - */
		/* need write cache flushing and no */
		/* additional allocation alignments */

		#define XFS_BMAPI_AFLAG(w) xfs_bmapi_aflag(w)
		static inline int xfs_bmapi_aflag(int w)
		@@ -102,6 +106,7 @@ typedef struct xfs_bmalloca {
		char userdata;/* set if is user data */
		char low; /* low on space, using seq'l ags */
		char aeof; /* allocated space at eof */
		char conv; /* overwriting unwritten extents */
		} xfs_bmalloca_t;

		#ifdef __KERNEL__

fs/xfs/xfs_dinode.h

+8 −3

Original line number	Diff line number	Diff line
		@@ -248,6 +248,8 @@ typedef enum xfs_dinode_fmt
		#define XFS_DIFLAG_RTINHERIT_BIT 8 /* create with realtime bit set */
		#define XFS_DIFLAG_PROJINHERIT_BIT 9 /* create with parents projid */
		#define XFS_DIFLAG_NOSYMLINKS_BIT 10 /* disallow symlink creation */
		#define XFS_DIFLAG_EXTSIZE_BIT 11 /* inode extent size allocator hint */
		#define XFS_DIFLAG_EXTSZINHERIT_BIT 12 /* inherit inode extent size */
		#define XFS_DIFLAG_REALTIME (1 << XFS_DIFLAG_REALTIME_BIT)
		#define XFS_DIFLAG_PREALLOC (1 << XFS_DIFLAG_PREALLOC_BIT)
		#define XFS_DIFLAG_NEWRTBM (1 << XFS_DIFLAG_NEWRTBM_BIT)
		@@ -259,11 +261,14 @@ typedef enum xfs_dinode_fmt
		#define XFS_DIFLAG_RTINHERIT (1 << XFS_DIFLAG_RTINHERIT_BIT)
		#define XFS_DIFLAG_PROJINHERIT (1 << XFS_DIFLAG_PROJINHERIT_BIT)
		#define XFS_DIFLAG_NOSYMLINKS (1 << XFS_DIFLAG_NOSYMLINKS_BIT)
		#define XFS_DIFLAG_EXTSIZE (1 << XFS_DIFLAG_EXTSIZE_BIT)
		#define XFS_DIFLAG_EXTSZINHERIT (1 << XFS_DIFLAG_EXTSZINHERIT_BIT)

		#define XFS_DIFLAG_ANY \
		(XFS_DIFLAG_REALTIME \| XFS_DIFLAG_PREALLOC \| XFS_DIFLAG_NEWRTBM \| \
		XFS_DIFLAG_IMMUTABLE \| XFS_DIFLAG_APPEND \| XFS_DIFLAG_SYNC \| \
		XFS_DIFLAG_NOATIME \| XFS_DIFLAG_NODUMP \| XFS_DIFLAG_RTINHERIT \| \
		XFS_DIFLAG_PROJINHERIT \| XFS_DIFLAG_NOSYMLINKS)
		XFS_DIFLAG_PROJINHERIT \| XFS_DIFLAG_NOSYMLINKS \| XFS_DIFLAG_EXTSIZE \| \
		XFS_DIFLAG_EXTSZINHERIT)

		#endif /* __XFS_DINODE_H__ */

fs/xfs/xfs_fs.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -65,6 +65,8 @@ struct fsxattr {
		#define XFS_XFLAG_RTINHERIT 0x00000100 /* create with rt bit set */
		#define XFS_XFLAG_PROJINHERIT 0x00000200 /* create with parents projid */
		#define XFS_XFLAG_NOSYMLINKS 0x00000400 /* disallow symlink creation */
		#define XFS_XFLAG_EXTSIZE 0x00000800 /* extent size allocator hint */
		#define XFS_XFLAG_EXTSZINHERIT 0x00001000 /* inherit inode extent size */
		#define XFS_XFLAG_HASATTR 0x80000000 /* no DIFLAG for this */

		/*

fs/xfs/xfs_inode.c

+14 −2

Original line number	Diff line number	Diff line
		@@ -809,6 +809,10 @@ _xfs_dic2xflags(
		flags \|= XFS_XFLAG_PROJINHERIT;
		if (di_flags & XFS_DIFLAG_NOSYMLINKS)
		flags \|= XFS_XFLAG_NOSYMLINKS;
		if (di_flags & XFS_DIFLAG_EXTSIZE)
		flags \|= XFS_XFLAG_EXTSIZE;
		if (di_flags & XFS_DIFLAG_EXTSZINHERIT)
		flags \|= XFS_XFLAG_EXTSZINHERIT;
		}

		return flags;
		@@ -1192,11 +1196,19 @@ xfs_ialloc(
		if ((mode & S_IFMT) == S_IFDIR) {
		if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
		di_flags \|= XFS_DIFLAG_RTINHERIT;
		} else {
		if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
		di_flags \|= XFS_DIFLAG_EXTSZINHERIT;
		ip->i_d.di_extsize = pip->i_d.di_extsize;
		}
		} else if ((mode & S_IFMT) == S_IFREG) {
		if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT) {
		di_flags \|= XFS_DIFLAG_REALTIME;
		ip->i_iocore.io_flags \|= XFS_IOCORE_RT;
		}
		if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
		di_flags \|= XFS_DIFLAG_EXTSIZE;
		ip->i_d.di_extsize = pip->i_d.di_extsize;
		}
		}
		if ((pip->i_d.di_flags & XFS_DIFLAG_NOATIME) &&
		xfs_inherit_noatime)
		@@ -1262,7 +1274,7 @@ xfs_isize_check(
		if ((ip->i_d.di_mode & S_IFMT) != S_IFREG)
		return;

		if ( ip->i_d.di_flags & XFS_DIFLAG_REALTIME )
		if (ip->i_d.di_flags & (XFS_DIFLAG_REALTIME \| XFS_DIFLAG_EXTSIZE))
		return;

		nimaps = 2;