1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
6 #include "libxfs_priv.h"
8 #include "xfs_shared.h"
9 #include "xfs_format.h"
10 #include "xfs_log_format.h"
11 #include "xfs_trans_resv.h"
12 #include "xfs_mount.h"
14 #include "xfs_inode.h"
15 #include "xfs_errortag.h"
16 #include "xfs_trans.h"
17 #include "xfs_ialloc.h"
22 * If we are doing readahead on an inode buffer, we might be in log recovery
23 * reading an inode allocation buffer that hasn't yet been replayed, and hence
24 * has not had the inode cores stamped into it. Hence for readahead, the buffer
25 * may be potentially invalid.
27 * If the readahead buffer is invalid, we need to mark it with an error and
28 * clear the DONE status of the buffer so that a followup read will re-read it
29 * from disk. We don't report the error otherwise to avoid warnings during log
30 * recovery and we don't get unnecessary panics on debug kernels. We use EIO here
31 * because all we want to do is say readahead failed; there is no-one to report
32 * the error to, so this will distinguish it from a non-ra verifier failure.
33 * Changes to this readahead error behaviour also need to be reflected in
34 * xfs_dquot_buf_readahead_verify().
41 struct xfs_mount
*mp
= bp
->b_mount
;
46 * Validate the magic number and version of every inode in the buffer
48 ni
= XFS_BB_TO_FSB(mp
, bp
->b_length
) * mp
->m_sb
.sb_inopblock
;
49 for (i
= 0; i
< ni
; i
++) {
50 struct xfs_dinode
*dip
;
51 xfs_agino_t unlinked_ino
;
54 dip
= xfs_buf_offset(bp
, (i
<< mp
->m_sb
.sb_inodelog
));
55 unlinked_ino
= be32_to_cpu(dip
->di_next_unlinked
);
56 di_ok
= xfs_verify_magic16(bp
, dip
->di_magic
) &&
57 xfs_dinode_good_version(mp
, dip
->di_version
) &&
58 xfs_verify_agino_or_null(bp
->b_pag
, unlinked_ino
);
59 if (unlikely(XFS_TEST_ERROR(!di_ok
, mp
,
60 XFS_ERRTAG_ITOBP_INOTOBP
))) {
62 bp
->b_flags
&= ~XBF_DONE
;
63 xfs_buf_ioerror(bp
, -EIO
);
69 "bad inode magic/vsn daddr %lld #%d (magic=%x)",
70 (unsigned long long)xfs_buf_daddr(bp
), i
,
71 be16_to_cpu(dip
->di_magic
));
73 xfs_buf_verifier_error(bp
, -EFSCORRUPTED
,
74 __func__
, dip
, sizeof(*dip
),
83 xfs_inode_buf_read_verify(
86 xfs_inode_buf_verify(bp
, false);
90 xfs_inode_buf_readahead_verify(
93 xfs_inode_buf_verify(bp
, true);
97 xfs_inode_buf_write_verify(
100 xfs_inode_buf_verify(bp
, false);
103 const struct xfs_buf_ops xfs_inode_buf_ops
= {
105 .magic16
= { cpu_to_be16(XFS_DINODE_MAGIC
),
106 cpu_to_be16(XFS_DINODE_MAGIC
) },
107 .verify_read
= xfs_inode_buf_read_verify
,
108 .verify_write
= xfs_inode_buf_write_verify
,
111 const struct xfs_buf_ops xfs_inode_buf_ra_ops
= {
112 .name
= "xfs_inode_ra",
113 .magic16
= { cpu_to_be16(XFS_DINODE_MAGIC
),
114 cpu_to_be16(XFS_DINODE_MAGIC
) },
115 .verify_read
= xfs_inode_buf_readahead_verify
,
116 .verify_write
= xfs_inode_buf_write_verify
,
121 * This routine is called to map an inode to the buffer containing the on-disk
122 * version of the inode. It returns a pointer to the buffer containing the
123 * on-disk inode in the bpp parameter.
127 struct xfs_mount
*mp
,
128 struct xfs_trans
*tp
,
129 struct xfs_imap
*imap
,
130 struct xfs_buf
**bpp
)
132 return xfs_trans_read_buf(mp
, tp
, mp
->m_ddev_targp
, imap
->im_blkno
,
133 imap
->im_len
, XBF_UNMAPPED
, bpp
,
137 static inline struct timespec64
xfs_inode_decode_bigtime(uint64_t ts
)
139 struct timespec64 tv
;
142 tv
.tv_sec
= xfs_bigtime_to_unix(div_u64_rem(ts
, NSEC_PER_SEC
, &n
));
148 /* Convert an ondisk timestamp to an incore timestamp. */
150 xfs_inode_from_disk_ts(
151 struct xfs_dinode
*dip
,
152 const xfs_timestamp_t ts
)
154 struct timespec64 tv
;
155 struct xfs_legacy_timestamp
*lts
;
157 if (xfs_dinode_has_bigtime(dip
))
158 return xfs_inode_decode_bigtime(be64_to_cpu(ts
));
160 lts
= (struct xfs_legacy_timestamp
*)&ts
;
161 tv
.tv_sec
= (int)be32_to_cpu(lts
->t_sec
);
162 tv
.tv_nsec
= (int)be32_to_cpu(lts
->t_nsec
);
169 struct xfs_inode
*ip
,
170 struct xfs_dinode
*from
)
172 struct inode
*inode
= VFS_I(ip
);
176 ASSERT(ip
->i_cowfp
== NULL
);
178 fa
= xfs_dinode_verify(ip
->i_mount
, ip
->i_ino
, from
);
180 xfs_inode_verifier_error(ip
, -EFSCORRUPTED
, "dinode", from
,
182 return -EFSCORRUPTED
;
186 * First get the permanent information that is needed to allocate an
187 * inode. If the inode is unused, mode is zero and we shouldn't mess
188 * with the uninitialized part of it.
190 if (!xfs_has_v3inodes(ip
->i_mount
))
191 ip
->i_flushiter
= be16_to_cpu(from
->di_flushiter
);
192 inode
->i_generation
= be32_to_cpu(from
->di_gen
);
193 inode
->i_mode
= be16_to_cpu(from
->di_mode
);
198 * Convert v1 inodes immediately to v2 inode format as this is the
199 * minimum inode version format we support in the rest of the code.
200 * They will also be unconditionally written back to disk as v2 inodes.
202 if (unlikely(from
->di_version
== 1)) {
203 set_nlink(inode
, be16_to_cpu(from
->di_onlink
));
206 set_nlink(inode
, be32_to_cpu(from
->di_nlink
));
207 ip
->i_projid
= (prid_t
)be16_to_cpu(from
->di_projid_hi
) << 16 |
208 be16_to_cpu(from
->di_projid_lo
);
211 i_uid_write(inode
, be32_to_cpu(from
->di_uid
));
212 i_gid_write(inode
, be32_to_cpu(from
->di_gid
));
215 * Time is signed, so need to convert to signed 32 bit before
216 * storing in inode timestamp which may be 64 bit. Otherwise
217 * a time before epoch is converted to a time long after epoch
220 inode_set_atime_to_ts(inode
,
221 xfs_inode_from_disk_ts(from
, from
->di_atime
));
222 inode_set_mtime_to_ts(inode
,
223 xfs_inode_from_disk_ts(from
, from
->di_mtime
));
224 inode_set_ctime_to_ts(inode
,
225 xfs_inode_from_disk_ts(from
, from
->di_ctime
));
227 ip
->i_disk_size
= be64_to_cpu(from
->di_size
);
228 ip
->i_nblocks
= be64_to_cpu(from
->di_nblocks
);
229 ip
->i_extsize
= be32_to_cpu(from
->di_extsize
);
230 ip
->i_forkoff
= from
->di_forkoff
;
231 ip
->i_diflags
= be16_to_cpu(from
->di_flags
);
232 ip
->i_next_unlinked
= be32_to_cpu(from
->di_next_unlinked
);
234 if (from
->di_dmevmask
|| from
->di_dmstate
)
235 xfs_iflags_set(ip
, XFS_IPRESERVE_DM_FIELDS
);
237 if (xfs_has_v3inodes(ip
->i_mount
)) {
238 inode_set_iversion_queried(inode
,
239 be64_to_cpu(from
->di_changecount
));
240 ip
->i_crtime
= xfs_inode_from_disk_ts(from
, from
->di_crtime
);
241 ip
->i_diflags2
= be64_to_cpu(from
->di_flags2
);
242 ip
->i_cowextsize
= be32_to_cpu(from
->di_cowextsize
);
245 error
= xfs_iformat_data_fork(ip
, from
);
248 if (from
->di_forkoff
) {
249 error
= xfs_iformat_attr_fork(ip
, from
);
251 goto out_destroy_data_fork
;
253 if (xfs_is_reflink_inode(ip
))
254 xfs_ifork_init_cow(ip
);
257 out_destroy_data_fork
:
258 xfs_idestroy_fork(&ip
->i_df
);
262 /* Convert an incore timestamp to an ondisk timestamp. */
263 static inline xfs_timestamp_t
264 xfs_inode_to_disk_ts(
265 struct xfs_inode
*ip
,
266 const struct timespec64 tv
)
268 struct xfs_legacy_timestamp
*lts
;
271 if (xfs_inode_has_bigtime(ip
))
272 return cpu_to_be64(xfs_inode_encode_bigtime(tv
));
274 lts
= (struct xfs_legacy_timestamp
*)&ts
;
275 lts
->t_sec
= cpu_to_be32(tv
.tv_sec
);
276 lts
->t_nsec
= cpu_to_be32(tv
.tv_nsec
);
282 xfs_inode_to_disk_iext_counters(
283 struct xfs_inode
*ip
,
284 struct xfs_dinode
*to
)
286 if (xfs_inode_has_large_extent_counts(ip
)) {
287 to
->di_big_nextents
= cpu_to_be64(xfs_ifork_nextents(&ip
->i_df
));
288 to
->di_big_anextents
= cpu_to_be32(xfs_ifork_nextents(&ip
->i_af
));
290 * We might be upgrading the inode to use larger extent counters
291 * than was previously used. Hence zero the unused field.
293 to
->di_nrext64_pad
= cpu_to_be16(0);
295 to
->di_nextents
= cpu_to_be32(xfs_ifork_nextents(&ip
->i_df
));
296 to
->di_anextents
= cpu_to_be16(xfs_ifork_nextents(&ip
->i_af
));
302 struct xfs_inode
*ip
,
303 struct xfs_dinode
*to
,
306 struct inode
*inode
= VFS_I(ip
);
308 to
->di_magic
= cpu_to_be16(XFS_DINODE_MAGIC
);
311 to
->di_format
= xfs_ifork_format(&ip
->i_df
);
312 to
->di_uid
= cpu_to_be32(i_uid_read(inode
));
313 to
->di_gid
= cpu_to_be32(i_gid_read(inode
));
314 to
->di_projid_lo
= cpu_to_be16(ip
->i_projid
& 0xffff);
315 to
->di_projid_hi
= cpu_to_be16(ip
->i_projid
>> 16);
317 to
->di_atime
= xfs_inode_to_disk_ts(ip
, inode_get_atime(inode
));
318 to
->di_mtime
= xfs_inode_to_disk_ts(ip
, inode_get_mtime(inode
));
319 to
->di_ctime
= xfs_inode_to_disk_ts(ip
, inode_get_ctime(inode
));
320 to
->di_nlink
= cpu_to_be32(inode
->i_nlink
);
321 to
->di_gen
= cpu_to_be32(inode
->i_generation
);
322 to
->di_mode
= cpu_to_be16(inode
->i_mode
);
324 to
->di_size
= cpu_to_be64(ip
->i_disk_size
);
325 to
->di_nblocks
= cpu_to_be64(ip
->i_nblocks
);
326 to
->di_extsize
= cpu_to_be32(ip
->i_extsize
);
327 to
->di_forkoff
= ip
->i_forkoff
;
328 to
->di_aformat
= xfs_ifork_format(&ip
->i_af
);
329 to
->di_flags
= cpu_to_be16(ip
->i_diflags
);
331 if (xfs_has_v3inodes(ip
->i_mount
)) {
333 to
->di_changecount
= cpu_to_be64(inode_peek_iversion(inode
));
334 to
->di_crtime
= xfs_inode_to_disk_ts(ip
, ip
->i_crtime
);
335 to
->di_flags2
= cpu_to_be64(ip
->i_diflags2
);
336 to
->di_cowextsize
= cpu_to_be32(ip
->i_cowextsize
);
337 to
->di_ino
= cpu_to_be64(ip
->i_ino
);
338 to
->di_lsn
= cpu_to_be64(lsn
);
339 memset(to
->di_pad2
, 0, sizeof(to
->di_pad2
));
340 uuid_copy(&to
->di_uuid
, &ip
->i_mount
->m_sb
.sb_meta_uuid
);
344 to
->di_flushiter
= cpu_to_be16(ip
->i_flushiter
);
345 memset(to
->di_v2_pad
, 0, sizeof(to
->di_v2_pad
));
348 xfs_inode_to_disk_iext_counters(ip
, to
);
351 static xfs_failaddr_t
352 xfs_dinode_verify_fork(
353 struct xfs_dinode
*dip
,
354 struct xfs_mount
*mp
,
357 xfs_extnum_t di_nextents
;
358 xfs_extnum_t max_extents
;
359 mode_t mode
= be16_to_cpu(dip
->di_mode
);
360 uint32_t fork_size
= XFS_DFORK_SIZE(dip
, mp
, whichfork
);
361 uint32_t fork_format
= XFS_DFORK_FORMAT(dip
, whichfork
);
363 di_nextents
= xfs_dfork_nextents(dip
, whichfork
);
366 * For fork types that can contain local data, check that the fork
367 * format matches the size of local data contained within the fork.
369 * For all types, check that when the size says the should be in extent
370 * or btree format, the inode isn't claiming it is in local format.
372 if (whichfork
== XFS_DATA_FORK
) {
373 if (S_ISDIR(mode
) || S_ISLNK(mode
)) {
374 if (be64_to_cpu(dip
->di_size
) <= fork_size
&&
375 fork_format
!= XFS_DINODE_FMT_LOCAL
)
376 return __this_address
;
379 if (be64_to_cpu(dip
->di_size
) > fork_size
&&
380 fork_format
== XFS_DINODE_FMT_LOCAL
)
381 return __this_address
;
384 switch (fork_format
) {
385 case XFS_DINODE_FMT_LOCAL
:
387 * No local regular files yet.
389 if (S_ISREG(mode
) && whichfork
== XFS_DATA_FORK
)
390 return __this_address
;
392 return __this_address
;
394 case XFS_DINODE_FMT_EXTENTS
:
395 if (di_nextents
> XFS_DFORK_MAXEXT(dip
, mp
, whichfork
))
396 return __this_address
;
398 case XFS_DINODE_FMT_BTREE
:
399 max_extents
= xfs_iext_max_nextents(
400 xfs_dinode_has_large_extent_counts(dip
),
402 if (di_nextents
> max_extents
)
403 return __this_address
;
406 return __this_address
;
411 static xfs_failaddr_t
412 xfs_dinode_verify_forkoff(
413 struct xfs_dinode
*dip
,
414 struct xfs_mount
*mp
)
416 if (!dip
->di_forkoff
)
419 switch (dip
->di_format
) {
420 case XFS_DINODE_FMT_DEV
:
421 if (dip
->di_forkoff
!= (roundup(sizeof(xfs_dev_t
), 8) >> 3))
422 return __this_address
;
424 case XFS_DINODE_FMT_LOCAL
: /* fall through ... */
425 case XFS_DINODE_FMT_EXTENTS
: /* fall through ... */
426 case XFS_DINODE_FMT_BTREE
:
427 if (dip
->di_forkoff
>= (XFS_LITINO(mp
) >> 3))
428 return __this_address
;
431 return __this_address
;
436 static xfs_failaddr_t
437 xfs_dinode_verify_nrext64(
438 struct xfs_mount
*mp
,
439 struct xfs_dinode
*dip
)
441 if (xfs_dinode_has_large_extent_counts(dip
)) {
442 if (!xfs_has_large_extent_counts(mp
))
443 return __this_address
;
444 if (dip
->di_nrext64_pad
!= 0)
445 return __this_address
;
446 } else if (dip
->di_version
>= 3) {
447 if (dip
->di_v3_pad
!= 0)
448 return __this_address
;
456 struct xfs_mount
*mp
,
458 struct xfs_dinode
*dip
)
465 xfs_extnum_t nextents
;
466 xfs_extnum_t naextents
;
467 xfs_filblks_t nblocks
;
469 if (dip
->di_magic
!= cpu_to_be16(XFS_DINODE_MAGIC
))
470 return __this_address
;
472 /* Verify v3 integrity information first */
473 if (dip
->di_version
>= 3) {
474 if (!xfs_has_v3inodes(mp
))
475 return __this_address
;
476 if (!xfs_verify_cksum((char *)dip
, mp
->m_sb
.sb_inodesize
,
478 return __this_address
;
479 if (be64_to_cpu(dip
->di_ino
) != ino
)
480 return __this_address
;
481 if (!uuid_equal(&dip
->di_uuid
, &mp
->m_sb
.sb_meta_uuid
))
482 return __this_address
;
485 /* don't allow invalid i_size */
486 di_size
= be64_to_cpu(dip
->di_size
);
487 if (di_size
& (1ULL << 63))
488 return __this_address
;
490 mode
= be16_to_cpu(dip
->di_mode
);
491 if (mode
&& xfs_mode_to_ftype(mode
) == XFS_DIR3_FT_UNKNOWN
)
492 return __this_address
;
494 /* No zero-length symlinks/dirs. */
495 if ((S_ISLNK(mode
) || S_ISDIR(mode
)) && di_size
== 0)
496 return __this_address
;
498 fa
= xfs_dinode_verify_nrext64(mp
, dip
);
502 nextents
= xfs_dfork_data_extents(dip
);
503 naextents
= xfs_dfork_attr_extents(dip
);
504 nblocks
= be64_to_cpu(dip
->di_nblocks
);
506 /* Fork checks carried over from xfs_iformat_fork */
507 if (mode
&& nextents
+ naextents
> nblocks
)
508 return __this_address
;
510 if (nextents
+ naextents
== 0 && nblocks
!= 0)
511 return __this_address
;
513 if (S_ISDIR(mode
) && nextents
> mp
->m_dir_geo
->max_extents
)
514 return __this_address
;
516 if (mode
&& XFS_DFORK_BOFF(dip
) > mp
->m_sb
.sb_inodesize
)
517 return __this_address
;
519 flags
= be16_to_cpu(dip
->di_flags
);
521 if (mode
&& (flags
& XFS_DIFLAG_REALTIME
) && !mp
->m_rtdev_targp
)
522 return __this_address
;
524 /* check for illegal values of forkoff */
525 fa
= xfs_dinode_verify_forkoff(dip
, mp
);
529 /* Do we have appropriate data fork formats for the mode? */
530 switch (mode
& S_IFMT
) {
535 if (dip
->di_format
!= XFS_DINODE_FMT_DEV
)
536 return __this_address
;
541 fa
= xfs_dinode_verify_fork(dip
, mp
, XFS_DATA_FORK
);
546 /* Uninitialized inode ok. */
549 return __this_address
;
552 if (dip
->di_forkoff
) {
553 fa
= xfs_dinode_verify_fork(dip
, mp
, XFS_ATTR_FORK
);
558 * If there is no fork offset, this may be a freshly-made inode
559 * in a new disk cluster, in which case di_aformat is zeroed.
560 * Otherwise, such an inode must be in EXTENTS format; this goes
561 * for freed inodes as well.
563 switch (dip
->di_aformat
) {
565 case XFS_DINODE_FMT_EXTENTS
:
568 return __this_address
;
571 return __this_address
;
574 /* extent size hint validation */
575 fa
= xfs_inode_validate_extsize(mp
, be32_to_cpu(dip
->di_extsize
),
580 /* only version 3 or greater inodes are extensively verified here */
581 if (dip
->di_version
< 3)
584 flags2
= be64_to_cpu(dip
->di_flags2
);
586 /* don't allow reflink/cowextsize if we don't have reflink */
587 if ((flags2
& (XFS_DIFLAG2_REFLINK
| XFS_DIFLAG2_COWEXTSIZE
)) &&
588 !xfs_has_reflink(mp
))
589 return __this_address
;
591 /* only regular files get reflink */
592 if ((flags2
& XFS_DIFLAG2_REFLINK
) && (mode
& S_IFMT
) != S_IFREG
)
593 return __this_address
;
595 /* don't let reflink and realtime mix */
596 if ((flags2
& XFS_DIFLAG2_REFLINK
) && (flags
& XFS_DIFLAG_REALTIME
))
597 return __this_address
;
599 /* COW extent size hint validation */
600 fa
= xfs_inode_validate_cowextsize(mp
, be32_to_cpu(dip
->di_cowextsize
),
601 mode
, flags
, flags2
);
605 /* bigtime iflag can only happen on bigtime filesystems */
606 if (xfs_dinode_has_bigtime(dip
) &&
607 !xfs_has_bigtime(mp
))
608 return __this_address
;
615 struct xfs_mount
*mp
,
616 struct xfs_dinode
*dip
)
620 if (dip
->di_version
< 3)
623 ASSERT(xfs_has_crc(mp
));
624 crc
= xfs_start_cksum_update((char *)dip
, mp
->m_sb
.sb_inodesize
,
626 dip
->di_crc
= xfs_end_cksum(crc
);
630 * Validate di_extsize hint.
632 * 1. Extent size hint is only valid for directories and regular files.
633 * 2. FS_XFLAG_EXTSIZE is only valid for regular files.
634 * 3. FS_XFLAG_EXTSZINHERIT is only valid for directories.
635 * 4. Hint cannot be larger than MAXTEXTLEN.
636 * 5. Can be changed on directories at any time.
637 * 6. Hint value of 0 turns off hints, clears inode flags.
638 * 7. Extent size must be a multiple of the appropriate block size.
639 * For realtime files, this is the rt extent size.
640 * 8. For non-realtime files, the extent size hint must be limited
641 * to half the AG size to avoid alignment extending the extent beyond the
645 xfs_inode_validate_extsize(
646 struct xfs_mount
*mp
,
654 uint32_t extsize_bytes
;
655 uint32_t blocksize_bytes
;
657 rt_flag
= (flags
& XFS_DIFLAG_REALTIME
);
658 hint_flag
= (flags
& XFS_DIFLAG_EXTSIZE
);
659 inherit_flag
= (flags
& XFS_DIFLAG_EXTSZINHERIT
);
660 extsize_bytes
= XFS_FSB_TO_B(mp
, extsize
);
663 * This comment describes a historic gap in this verifier function.
665 * For a directory with both RTINHERIT and EXTSZINHERIT flags set, this
666 * function has never checked that the extent size hint is an integer
667 * multiple of the realtime extent size. Since we allow users to set
668 * this combination on non-rt filesystems /and/ to change the rt
669 * extent size when adding a rt device to a filesystem, the net effect
670 * is that users can configure a filesystem anticipating one rt
671 * geometry and change their minds later. Directories do not use the
672 * extent size hint, so this is harmless for them.
674 * If a directory with a misaligned extent size hint is allowed to
675 * propagate that hint into a new regular realtime file, the result
676 * is that the inode cluster buffer verifier will trigger a corruption
677 * shutdown the next time it is run, because the verifier has always
678 * enforced the alignment rule for regular files.
680 * Because we allow administrators to set a new rt extent size when
681 * adding a rt section, we cannot add a check to this verifier because
682 * that will result a new source of directory corruption errors when
683 * reading an existing filesystem. Instead, we rely on callers to
684 * decide when alignment checks are appropriate, and fix things up as
689 blocksize_bytes
= XFS_FSB_TO_B(mp
, mp
->m_sb
.sb_rextsize
);
691 blocksize_bytes
= mp
->m_sb
.sb_blocksize
;
693 if ((hint_flag
|| inherit_flag
) && !(S_ISDIR(mode
) || S_ISREG(mode
)))
694 return __this_address
;
696 if (hint_flag
&& !S_ISREG(mode
))
697 return __this_address
;
699 if (inherit_flag
&& !S_ISDIR(mode
))
700 return __this_address
;
702 if ((hint_flag
|| inherit_flag
) && extsize
== 0)
703 return __this_address
;
705 /* free inodes get flags set to zero but extsize remains */
706 if (mode
&& !(hint_flag
|| inherit_flag
) && extsize
!= 0)
707 return __this_address
;
709 if (extsize_bytes
% blocksize_bytes
)
710 return __this_address
;
712 if (extsize
> XFS_MAX_BMBT_EXTLEN
)
713 return __this_address
;
715 if (!rt_flag
&& extsize
> mp
->m_sb
.sb_agblocks
/ 2)
716 return __this_address
;
722 * Validate di_cowextsize hint.
724 * 1. CoW extent size hint can only be set if reflink is enabled on the fs.
725 * The inode does not have to have any shared blocks, but it must be a v3.
726 * 2. FS_XFLAG_COWEXTSIZE is only valid for directories and regular files;
727 * for a directory, the hint is propagated to new files.
728 * 3. Can be changed on files & directories at any time.
729 * 4. Hint value of 0 turns off hints, clears inode flags.
730 * 5. Extent size must be a multiple of the appropriate block size.
731 * 6. The extent size hint must be limited to half the AG size to avoid
732 * alignment extending the extent beyond the limits of the AG.
735 xfs_inode_validate_cowextsize(
736 struct xfs_mount
*mp
,
744 uint32_t cowextsize_bytes
;
746 rt_flag
= (flags
& XFS_DIFLAG_REALTIME
);
747 hint_flag
= (flags2
& XFS_DIFLAG2_COWEXTSIZE
);
748 cowextsize_bytes
= XFS_FSB_TO_B(mp
, cowextsize
);
750 if (hint_flag
&& !xfs_has_reflink(mp
))
751 return __this_address
;
753 if (hint_flag
&& !(S_ISDIR(mode
) || S_ISREG(mode
)))
754 return __this_address
;
756 if (hint_flag
&& cowextsize
== 0)
757 return __this_address
;
759 /* free inodes get flags set to zero but cowextsize remains */
760 if (mode
&& !hint_flag
&& cowextsize
!= 0)
761 return __this_address
;
763 if (hint_flag
&& rt_flag
)
764 return __this_address
;
766 if (cowextsize_bytes
% mp
->m_sb
.sb_blocksize
)
767 return __this_address
;
769 if (cowextsize
> XFS_MAX_BMBT_EXTLEN
)
770 return __this_address
;
772 if (cowextsize
> mp
->m_sb
.sb_agblocks
/ 2)
773 return __this_address
;