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"
13 #include "xfs_inode.h"
14 #include "xfs_trans.h"
15 #include "xfs_ialloc.h"
20 * Check that none of the inode's in the buffer have a next
21 * unlinked field of 0.
32 for (i
= 0; i
< M_IGEO(mp
)->inodes_per_cluster
; i
++) {
33 dip
= xfs_buf_offset(bp
, i
* mp
->m_sb
.sb_inodesize
);
34 if (!dip
->di_next_unlinked
) {
36 "Detected bogus zero next_unlinked field in inode %d buffer 0x%llx.",
37 i
, (long long)bp
->b_bn
);
44 xfs_dinode_good_version(
48 if (xfs_sb_version_hascrc(&mp
->m_sb
))
51 return version
== 1 || version
== 2;
55 * If we are doing readahead on an inode buffer, we might be in log recovery
56 * reading an inode allocation buffer that hasn't yet been replayed, and hence
57 * has not had the inode cores stamped into it. Hence for readahead, the buffer
58 * may be potentially invalid.
60 * If the readahead buffer is invalid, we need to mark it with an error and
61 * clear the DONE status of the buffer so that a followup read will re-read it
62 * from disk. We don't report the error otherwise to avoid warnings during log
63 * recovery and we don't get unnecssary panics on debug kernels. We use EIO here
64 * because all we want to do is say readahead failed; there is no-one to report
65 * the error to, so this will distinguish it from a non-ra verifier failure.
66 * Changes to this readahead error behavour also need to be reflected in
67 * xfs_dquot_buf_readahead_verify().
74 struct xfs_mount
*mp
= bp
->b_mount
;
80 * Validate the magic number and version of every inode in the buffer
82 agno
= xfs_daddr_to_agno(mp
, XFS_BUF_ADDR(bp
));
83 ni
= XFS_BB_TO_FSB(mp
, bp
->b_length
) * mp
->m_sb
.sb_inopblock
;
84 for (i
= 0; i
< ni
; i
++) {
87 xfs_agino_t unlinked_ino
;
89 dip
= xfs_buf_offset(bp
, (i
<< mp
->m_sb
.sb_inodelog
));
90 unlinked_ino
= be32_to_cpu(dip
->di_next_unlinked
);
91 di_ok
= xfs_verify_magic16(bp
, dip
->di_magic
) &&
92 xfs_dinode_good_version(mp
, dip
->di_version
) &&
93 xfs_verify_agino_or_null(mp
, agno
, unlinked_ino
);
94 if (unlikely(XFS_TEST_ERROR(!di_ok
, mp
,
95 XFS_ERRTAG_ITOBP_INOTOBP
))) {
97 bp
->b_flags
&= ~XBF_DONE
;
98 xfs_buf_ioerror(bp
, -EIO
);
104 "bad inode magic/vsn daddr %lld #%d (magic=%x)",
105 (unsigned long long)bp
->b_bn
, i
,
106 be16_to_cpu(dip
->di_magic
));
108 xfs_buf_verifier_error(bp
, -EFSCORRUPTED
,
109 __func__
, dip
, sizeof(*dip
),
118 xfs_inode_buf_read_verify(
121 xfs_inode_buf_verify(bp
, false);
125 xfs_inode_buf_readahead_verify(
128 xfs_inode_buf_verify(bp
, true);
132 xfs_inode_buf_write_verify(
135 xfs_inode_buf_verify(bp
, false);
138 const struct xfs_buf_ops xfs_inode_buf_ops
= {
140 .magic16
= { cpu_to_be16(XFS_DINODE_MAGIC
),
141 cpu_to_be16(XFS_DINODE_MAGIC
) },
142 .verify_read
= xfs_inode_buf_read_verify
,
143 .verify_write
= xfs_inode_buf_write_verify
,
146 const struct xfs_buf_ops xfs_inode_buf_ra_ops
= {
147 .name
= "xfs_inode_ra",
148 .magic16
= { cpu_to_be16(XFS_DINODE_MAGIC
),
149 cpu_to_be16(XFS_DINODE_MAGIC
) },
150 .verify_read
= xfs_inode_buf_readahead_verify
,
151 .verify_write
= xfs_inode_buf_write_verify
,
156 * This routine is called to map an inode to the buffer containing the on-disk
157 * version of the inode. It returns a pointer to the buffer containing the
158 * on-disk inode in the bpp parameter, and in the dipp parameter it returns a
159 * pointer to the on-disk inode within that buffer.
161 * If a non-zero error is returned, then the contents of bpp and dipp are
166 struct xfs_mount
*mp
,
167 struct xfs_trans
*tp
,
168 struct xfs_imap
*imap
,
169 struct xfs_dinode
**dipp
,
170 struct xfs_buf
**bpp
,
177 buf_flags
|= XBF_UNMAPPED
;
178 error
= xfs_trans_read_buf(mp
, tp
, mp
->m_ddev_targp
, imap
->im_blkno
,
179 (int)imap
->im_len
, buf_flags
, &bp
,
182 if (error
== -EAGAIN
) {
183 ASSERT(buf_flags
& XBF_TRYLOCK
);
186 xfs_warn(mp
, "%s: xfs_trans_read_buf() returned error %d.",
192 *dipp
= xfs_buf_offset(bp
, imap
->im_boffset
);
198 struct xfs_inode
*ip
,
199 struct xfs_dinode
*from
)
201 struct xfs_icdinode
*to
= &ip
->i_d
;
202 struct inode
*inode
= VFS_I(ip
);
206 * Convert v1 inodes immediately to v2 inode format as this is the
207 * minimum inode version format we support in the rest of the code.
209 to
->di_version
= from
->di_version
;
210 if (to
->di_version
== 1) {
211 set_nlink(inode
, be16_to_cpu(from
->di_onlink
));
212 to
->di_projid_lo
= 0;
213 to
->di_projid_hi
= 0;
216 set_nlink(inode
, be32_to_cpu(from
->di_nlink
));
217 to
->di_projid_lo
= be16_to_cpu(from
->di_projid_lo
);
218 to
->di_projid_hi
= be16_to_cpu(from
->di_projid_hi
);
221 to
->di_format
= from
->di_format
;
222 to
->di_uid
= be32_to_cpu(from
->di_uid
);
223 to
->di_gid
= be32_to_cpu(from
->di_gid
);
224 to
->di_flushiter
= be16_to_cpu(from
->di_flushiter
);
227 * Time is signed, so need to convert to signed 32 bit before
228 * storing in inode timestamp which may be 64 bit. Otherwise
229 * a time before epoch is converted to a time long after epoch
232 inode
->i_atime
.tv_sec
= (int)be32_to_cpu(from
->di_atime
.t_sec
);
233 inode
->i_atime
.tv_nsec
= (int)be32_to_cpu(from
->di_atime
.t_nsec
);
234 inode
->i_mtime
.tv_sec
= (int)be32_to_cpu(from
->di_mtime
.t_sec
);
235 inode
->i_mtime
.tv_nsec
= (int)be32_to_cpu(from
->di_mtime
.t_nsec
);
236 inode
->i_ctime
.tv_sec
= (int)be32_to_cpu(from
->di_ctime
.t_sec
);
237 inode
->i_ctime
.tv_nsec
= (int)be32_to_cpu(from
->di_ctime
.t_nsec
);
238 inode
->i_generation
= be32_to_cpu(from
->di_gen
);
239 inode
->i_mode
= be16_to_cpu(from
->di_mode
);
241 to
->di_size
= be64_to_cpu(from
->di_size
);
242 to
->di_nblocks
= be64_to_cpu(from
->di_nblocks
);
243 to
->di_extsize
= be32_to_cpu(from
->di_extsize
);
244 to
->di_nextents
= be32_to_cpu(from
->di_nextents
);
245 to
->di_anextents
= be16_to_cpu(from
->di_anextents
);
246 to
->di_forkoff
= from
->di_forkoff
;
247 to
->di_aformat
= from
->di_aformat
;
248 to
->di_dmevmask
= be32_to_cpu(from
->di_dmevmask
);
249 to
->di_dmstate
= be16_to_cpu(from
->di_dmstate
);
250 to
->di_flags
= be16_to_cpu(from
->di_flags
);
252 if (to
->di_version
== 3) {
253 inode_set_iversion_queried(inode
,
254 be64_to_cpu(from
->di_changecount
));
255 to
->di_crtime
.t_sec
= be32_to_cpu(from
->di_crtime
.t_sec
);
256 to
->di_crtime
.t_nsec
= be32_to_cpu(from
->di_crtime
.t_nsec
);
257 to
->di_flags2
= be64_to_cpu(from
->di_flags2
);
258 to
->di_cowextsize
= be32_to_cpu(from
->di_cowextsize
);
264 struct xfs_inode
*ip
,
265 struct xfs_dinode
*to
,
268 struct xfs_icdinode
*from
= &ip
->i_d
;
269 struct inode
*inode
= VFS_I(ip
);
271 to
->di_magic
= cpu_to_be16(XFS_DINODE_MAGIC
);
274 to
->di_version
= from
->di_version
;
275 to
->di_format
= from
->di_format
;
276 to
->di_uid
= cpu_to_be32(from
->di_uid
);
277 to
->di_gid
= cpu_to_be32(from
->di_gid
);
278 to
->di_projid_lo
= cpu_to_be16(from
->di_projid_lo
);
279 to
->di_projid_hi
= cpu_to_be16(from
->di_projid_hi
);
281 memset(to
->di_pad
, 0, sizeof(to
->di_pad
));
282 to
->di_atime
.t_sec
= cpu_to_be32(inode
->i_atime
.tv_sec
);
283 to
->di_atime
.t_nsec
= cpu_to_be32(inode
->i_atime
.tv_nsec
);
284 to
->di_mtime
.t_sec
= cpu_to_be32(inode
->i_mtime
.tv_sec
);
285 to
->di_mtime
.t_nsec
= cpu_to_be32(inode
->i_mtime
.tv_nsec
);
286 to
->di_ctime
.t_sec
= cpu_to_be32(inode
->i_ctime
.tv_sec
);
287 to
->di_ctime
.t_nsec
= cpu_to_be32(inode
->i_ctime
.tv_nsec
);
288 to
->di_nlink
= cpu_to_be32(inode
->i_nlink
);
289 to
->di_gen
= cpu_to_be32(inode
->i_generation
);
290 to
->di_mode
= cpu_to_be16(inode
->i_mode
);
292 to
->di_size
= cpu_to_be64(from
->di_size
);
293 to
->di_nblocks
= cpu_to_be64(from
->di_nblocks
);
294 to
->di_extsize
= cpu_to_be32(from
->di_extsize
);
295 to
->di_nextents
= cpu_to_be32(from
->di_nextents
);
296 to
->di_anextents
= cpu_to_be16(from
->di_anextents
);
297 to
->di_forkoff
= from
->di_forkoff
;
298 to
->di_aformat
= from
->di_aformat
;
299 to
->di_dmevmask
= cpu_to_be32(from
->di_dmevmask
);
300 to
->di_dmstate
= cpu_to_be16(from
->di_dmstate
);
301 to
->di_flags
= cpu_to_be16(from
->di_flags
);
303 if (from
->di_version
== 3) {
304 to
->di_changecount
= cpu_to_be64(inode_peek_iversion(inode
));
305 to
->di_crtime
.t_sec
= cpu_to_be32(from
->di_crtime
.t_sec
);
306 to
->di_crtime
.t_nsec
= cpu_to_be32(from
->di_crtime
.t_nsec
);
307 to
->di_flags2
= cpu_to_be64(from
->di_flags2
);
308 to
->di_cowextsize
= cpu_to_be32(from
->di_cowextsize
);
309 to
->di_ino
= cpu_to_be64(ip
->i_ino
);
310 to
->di_lsn
= cpu_to_be64(lsn
);
311 memset(to
->di_pad2
, 0, sizeof(to
->di_pad2
));
312 uuid_copy(&to
->di_uuid
, &ip
->i_mount
->m_sb
.sb_meta_uuid
);
313 to
->di_flushiter
= 0;
315 to
->di_flushiter
= cpu_to_be16(from
->di_flushiter
);
320 xfs_log_dinode_to_disk(
321 struct xfs_log_dinode
*from
,
322 struct xfs_dinode
*to
)
324 to
->di_magic
= cpu_to_be16(from
->di_magic
);
325 to
->di_mode
= cpu_to_be16(from
->di_mode
);
326 to
->di_version
= from
->di_version
;
327 to
->di_format
= from
->di_format
;
329 to
->di_uid
= cpu_to_be32(from
->di_uid
);
330 to
->di_gid
= cpu_to_be32(from
->di_gid
);
331 to
->di_nlink
= cpu_to_be32(from
->di_nlink
);
332 to
->di_projid_lo
= cpu_to_be16(from
->di_projid_lo
);
333 to
->di_projid_hi
= cpu_to_be16(from
->di_projid_hi
);
334 memcpy(to
->di_pad
, from
->di_pad
, sizeof(to
->di_pad
));
336 to
->di_atime
.t_sec
= cpu_to_be32(from
->di_atime
.t_sec
);
337 to
->di_atime
.t_nsec
= cpu_to_be32(from
->di_atime
.t_nsec
);
338 to
->di_mtime
.t_sec
= cpu_to_be32(from
->di_mtime
.t_sec
);
339 to
->di_mtime
.t_nsec
= cpu_to_be32(from
->di_mtime
.t_nsec
);
340 to
->di_ctime
.t_sec
= cpu_to_be32(from
->di_ctime
.t_sec
);
341 to
->di_ctime
.t_nsec
= cpu_to_be32(from
->di_ctime
.t_nsec
);
343 to
->di_size
= cpu_to_be64(from
->di_size
);
344 to
->di_nblocks
= cpu_to_be64(from
->di_nblocks
);
345 to
->di_extsize
= cpu_to_be32(from
->di_extsize
);
346 to
->di_nextents
= cpu_to_be32(from
->di_nextents
);
347 to
->di_anextents
= cpu_to_be16(from
->di_anextents
);
348 to
->di_forkoff
= from
->di_forkoff
;
349 to
->di_aformat
= from
->di_aformat
;
350 to
->di_dmevmask
= cpu_to_be32(from
->di_dmevmask
);
351 to
->di_dmstate
= cpu_to_be16(from
->di_dmstate
);
352 to
->di_flags
= cpu_to_be16(from
->di_flags
);
353 to
->di_gen
= cpu_to_be32(from
->di_gen
);
355 if (from
->di_version
== 3) {
356 to
->di_changecount
= cpu_to_be64(from
->di_changecount
);
357 to
->di_crtime
.t_sec
= cpu_to_be32(from
->di_crtime
.t_sec
);
358 to
->di_crtime
.t_nsec
= cpu_to_be32(from
->di_crtime
.t_nsec
);
359 to
->di_flags2
= cpu_to_be64(from
->di_flags2
);
360 to
->di_cowextsize
= cpu_to_be32(from
->di_cowextsize
);
361 to
->di_ino
= cpu_to_be64(from
->di_ino
);
362 to
->di_lsn
= cpu_to_be64(from
->di_lsn
);
363 memcpy(to
->di_pad2
, from
->di_pad2
, sizeof(to
->di_pad2
));
364 uuid_copy(&to
->di_uuid
, &from
->di_uuid
);
365 to
->di_flushiter
= 0;
367 to
->di_flushiter
= cpu_to_be16(from
->di_flushiter
);
371 static xfs_failaddr_t
372 xfs_dinode_verify_fork(
373 struct xfs_dinode
*dip
,
374 struct xfs_mount
*mp
,
377 uint32_t di_nextents
= XFS_DFORK_NEXTENTS(dip
, whichfork
);
379 switch (XFS_DFORK_FORMAT(dip
, whichfork
)) {
380 case XFS_DINODE_FMT_LOCAL
:
382 * no local regular files yet
384 if (whichfork
== XFS_DATA_FORK
) {
385 if (S_ISREG(be16_to_cpu(dip
->di_mode
)))
386 return __this_address
;
387 if (be64_to_cpu(dip
->di_size
) >
388 XFS_DFORK_SIZE(dip
, mp
, whichfork
))
389 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 if (whichfork
== XFS_ATTR_FORK
) {
400 if (di_nextents
> MAXAEXTNUM
)
401 return __this_address
;
402 } else if (di_nextents
> MAXEXTNUM
) {
403 return __this_address
;
407 return __this_address
;
412 static xfs_failaddr_t
413 xfs_dinode_verify_forkoff(
414 struct xfs_dinode
*dip
,
415 struct xfs_mount
*mp
)
417 if (!XFS_DFORK_Q(dip
))
420 switch (dip
->di_format
) {
421 case XFS_DINODE_FMT_DEV
:
422 if (dip
->di_forkoff
!= (roundup(sizeof(xfs_dev_t
), 8) >> 3))
423 return __this_address
;
425 case XFS_DINODE_FMT_LOCAL
: /* fall through ... */
426 case XFS_DINODE_FMT_EXTENTS
: /* fall through ... */
427 case XFS_DINODE_FMT_BTREE
:
428 if (dip
->di_forkoff
>= (XFS_LITINO(mp
, dip
->di_version
) >> 3))
429 return __this_address
;
432 return __this_address
;
439 struct xfs_mount
*mp
,
441 struct xfs_dinode
*dip
)
449 if (dip
->di_magic
!= cpu_to_be16(XFS_DINODE_MAGIC
))
450 return __this_address
;
452 /* Verify v3 integrity information first */
453 if (dip
->di_version
>= 3) {
454 if (!xfs_sb_version_hascrc(&mp
->m_sb
))
455 return __this_address
;
456 if (!xfs_verify_cksum((char *)dip
, mp
->m_sb
.sb_inodesize
,
458 return __this_address
;
459 if (be64_to_cpu(dip
->di_ino
) != ino
)
460 return __this_address
;
461 if (!uuid_equal(&dip
->di_uuid
, &mp
->m_sb
.sb_meta_uuid
))
462 return __this_address
;
465 /* don't allow invalid i_size */
466 di_size
= be64_to_cpu(dip
->di_size
);
467 if (di_size
& (1ULL << 63))
468 return __this_address
;
470 mode
= be16_to_cpu(dip
->di_mode
);
471 if (mode
&& xfs_mode_to_ftype(mode
) == XFS_DIR3_FT_UNKNOWN
)
472 return __this_address
;
474 /* No zero-length symlinks/dirs. */
475 if ((S_ISLNK(mode
) || S_ISDIR(mode
)) && di_size
== 0)
476 return __this_address
;
478 /* Fork checks carried over from xfs_iformat_fork */
480 be32_to_cpu(dip
->di_nextents
) + be16_to_cpu(dip
->di_anextents
) >
481 be64_to_cpu(dip
->di_nblocks
))
482 return __this_address
;
484 if (mode
&& XFS_DFORK_BOFF(dip
) > mp
->m_sb
.sb_inodesize
)
485 return __this_address
;
487 flags
= be16_to_cpu(dip
->di_flags
);
489 if (mode
&& (flags
& XFS_DIFLAG_REALTIME
) && !mp
->m_rtdev_targp
)
490 return __this_address
;
492 /* check for illegal values of forkoff */
493 fa
= xfs_dinode_verify_forkoff(dip
, mp
);
497 /* Do we have appropriate data fork formats for the mode? */
498 switch (mode
& S_IFMT
) {
503 if (dip
->di_format
!= XFS_DINODE_FMT_DEV
)
504 return __this_address
;
509 fa
= xfs_dinode_verify_fork(dip
, mp
, XFS_DATA_FORK
);
514 /* Uninitialized inode ok. */
517 return __this_address
;
520 if (XFS_DFORK_Q(dip
)) {
521 fa
= xfs_dinode_verify_fork(dip
, mp
, XFS_ATTR_FORK
);
526 * If there is no fork offset, this may be a freshly-made inode
527 * in a new disk cluster, in which case di_aformat is zeroed.
528 * Otherwise, such an inode must be in EXTENTS format; this goes
529 * for freed inodes as well.
531 switch (dip
->di_aformat
) {
533 case XFS_DINODE_FMT_EXTENTS
:
536 return __this_address
;
538 if (dip
->di_anextents
)
539 return __this_address
;
542 /* extent size hint validation */
543 fa
= xfs_inode_validate_extsize(mp
, be32_to_cpu(dip
->di_extsize
),
548 /* only version 3 or greater inodes are extensively verified here */
549 if (dip
->di_version
< 3)
552 flags2
= be64_to_cpu(dip
->di_flags2
);
554 /* don't allow reflink/cowextsize if we don't have reflink */
555 if ((flags2
& (XFS_DIFLAG2_REFLINK
| XFS_DIFLAG2_COWEXTSIZE
)) &&
556 !xfs_sb_version_hasreflink(&mp
->m_sb
))
557 return __this_address
;
559 /* only regular files get reflink */
560 if ((flags2
& XFS_DIFLAG2_REFLINK
) && (mode
& S_IFMT
) != S_IFREG
)
561 return __this_address
;
563 /* don't let reflink and realtime mix */
564 if ((flags2
& XFS_DIFLAG2_REFLINK
) && (flags
& XFS_DIFLAG_REALTIME
))
565 return __this_address
;
567 /* don't let reflink and dax mix */
568 if ((flags2
& XFS_DIFLAG2_REFLINK
) && (flags2
& XFS_DIFLAG2_DAX
))
569 return __this_address
;
571 /* COW extent size hint validation */
572 fa
= xfs_inode_validate_cowextsize(mp
, be32_to_cpu(dip
->di_cowextsize
),
573 mode
, flags
, flags2
);
582 struct xfs_mount
*mp
,
583 struct xfs_dinode
*dip
)
587 if (dip
->di_version
< 3)
590 ASSERT(xfs_sb_version_hascrc(&mp
->m_sb
));
591 crc
= xfs_start_cksum_update((char *)dip
, mp
->m_sb
.sb_inodesize
,
593 dip
->di_crc
= xfs_end_cksum(crc
);
597 * Read the disk inode attributes into the in-core inode structure.
599 * For version 5 superblocks, if we are initialising a new inode and we are not
600 * utilising the XFS_MOUNT_IKEEP inode cluster mode, we can simple build the new
601 * inode core with a random generation number. If we are keeping inodes around,
602 * we need to read the inode cluster to get the existing generation number off
603 * disk. Further, if we are using version 4 superblocks (i.e. v1/v2 inode
604 * format) then log recovery is dependent on the di_flushiter field being
605 * initialised from the current on-disk value and hence we must also read the
621 * Fill in the location information in the in-core inode.
623 error
= xfs_imap(mp
, tp
, ip
->i_ino
, &ip
->i_imap
, iget_flags
);
627 /* shortcut IO on inode allocation if possible */
628 if ((iget_flags
& XFS_IGET_CREATE
) &&
629 xfs_sb_version_hascrc(&mp
->m_sb
) &&
630 !(mp
->m_flags
& XFS_MOUNT_IKEEP
)) {
631 /* initialise the on-disk inode core */
632 memset(&ip
->i_d
, 0, sizeof(ip
->i_d
));
633 VFS_I(ip
)->i_generation
= prandom_u32();
634 ip
->i_d
.di_version
= 3;
639 * Get pointers to the on-disk inode and the buffer containing it.
641 error
= xfs_imap_to_bp(mp
, tp
, &ip
->i_imap
, &dip
, &bp
, 0, iget_flags
);
645 /* even unallocated inodes are verified */
646 fa
= xfs_dinode_verify(mp
, ip
->i_ino
, dip
);
648 xfs_inode_verifier_error(ip
, -EFSCORRUPTED
, "dinode", dip
,
650 error
= -EFSCORRUPTED
;
655 * If the on-disk inode is already linked to a directory
656 * entry, copy all of the inode into the in-core inode.
657 * xfs_iformat_fork() handles copying in the inode format
658 * specific information.
659 * Otherwise, just get the truly permanent information.
662 xfs_inode_from_disk(ip
, dip
);
663 error
= xfs_iformat_fork(ip
, dip
);
666 xfs_alert(mp
, "%s: xfs_iformat() returned error %d",
673 * Partial initialisation of the in-core inode. Just the bits
674 * that xfs_ialloc won't overwrite or relies on being correct.
676 ip
->i_d
.di_version
= dip
->di_version
;
677 VFS_I(ip
)->i_generation
= be32_to_cpu(dip
->di_gen
);
678 ip
->i_d
.di_flushiter
= be16_to_cpu(dip
->di_flushiter
);
681 * Make sure to pull in the mode here as well in
682 * case the inode is released without being used.
683 * This ensures that xfs_inactive() will see that
684 * the inode is already free and not try to mess
685 * with the uninitialized part of it.
687 VFS_I(ip
)->i_mode
= 0;
690 ASSERT(ip
->i_d
.di_version
>= 2);
691 ip
->i_delayed_blks
= 0;
694 * Mark the buffer containing the inode as something to keep
695 * around for a while. This helps to keep recently accessed
696 * meta-data in-core longer.
698 xfs_buf_set_ref(bp
, XFS_INO_REF
);
701 * Use xfs_trans_brelse() to release the buffer containing the on-disk
702 * inode, because it was acquired with xfs_trans_read_buf() in
703 * xfs_imap_to_bp() above. If tp is NULL, this is just a normal
704 * brelse(). If we're within a transaction, then xfs_trans_brelse()
705 * will only release the buffer if it is not dirty within the
706 * transaction. It will be OK to release the buffer in this case,
707 * because inodes on disk are never destroyed and we will be locking the
708 * new in-core inode before putting it in the cache where other
709 * processes can find it. Thus we don't have to worry about the inode
710 * being changed just because we released the buffer.
713 xfs_trans_brelse(tp
, bp
);
718 * Validate di_extsize hint.
720 * The rules are documented at xfs_ioctl_setattr_check_extsize().
721 * These functions must be kept in sync with each other.
724 xfs_inode_validate_extsize(
725 struct xfs_mount
*mp
,
733 uint32_t extsize_bytes
;
734 uint32_t blocksize_bytes
;
736 rt_flag
= (flags
& XFS_DIFLAG_REALTIME
);
737 hint_flag
= (flags
& XFS_DIFLAG_EXTSIZE
);
738 inherit_flag
= (flags
& XFS_DIFLAG_EXTSZINHERIT
);
739 extsize_bytes
= XFS_FSB_TO_B(mp
, extsize
);
742 blocksize_bytes
= mp
->m_sb
.sb_rextsize
<< mp
->m_sb
.sb_blocklog
;
744 blocksize_bytes
= mp
->m_sb
.sb_blocksize
;
746 if ((hint_flag
|| inherit_flag
) && !(S_ISDIR(mode
) || S_ISREG(mode
)))
747 return __this_address
;
749 if (hint_flag
&& !S_ISREG(mode
))
750 return __this_address
;
752 if (inherit_flag
&& !S_ISDIR(mode
))
753 return __this_address
;
755 if ((hint_flag
|| inherit_flag
) && extsize
== 0)
756 return __this_address
;
758 /* free inodes get flags set to zero but extsize remains */
759 if (mode
&& !(hint_flag
|| inherit_flag
) && extsize
!= 0)
760 return __this_address
;
762 if (extsize_bytes
% blocksize_bytes
)
763 return __this_address
;
765 if (extsize
> MAXEXTLEN
)
766 return __this_address
;
768 if (!rt_flag
&& extsize
> mp
->m_sb
.sb_agblocks
/ 2)
769 return __this_address
;
775 * Validate di_cowextsize hint.
777 * The rules are documented at xfs_ioctl_setattr_check_cowextsize().
778 * These functions must be kept in sync with each other.
781 xfs_inode_validate_cowextsize(
782 struct xfs_mount
*mp
,
790 uint32_t cowextsize_bytes
;
792 rt_flag
= (flags
& XFS_DIFLAG_REALTIME
);
793 hint_flag
= (flags2
& XFS_DIFLAG2_COWEXTSIZE
);
794 cowextsize_bytes
= XFS_FSB_TO_B(mp
, cowextsize
);
796 if (hint_flag
&& !xfs_sb_version_hasreflink(&mp
->m_sb
))
797 return __this_address
;
799 if (hint_flag
&& !(S_ISDIR(mode
) || S_ISREG(mode
)))
800 return __this_address
;
802 if (hint_flag
&& cowextsize
== 0)
803 return __this_address
;
805 /* free inodes get flags set to zero but cowextsize remains */
806 if (mode
&& !hint_flag
&& cowextsize
!= 0)
807 return __this_address
;
809 if (hint_flag
&& rt_flag
)
810 return __this_address
;
812 if (cowextsize_bytes
% mp
->m_sb
.sb_blocksize
)
813 return __this_address
;
815 if (cowextsize
> MAXEXTLEN
)
816 return __this_address
;
818 if (cowextsize
> mp
->m_sb
.sb_agblocks
/ 2)
819 return __this_address
;