2013-08-12 10:49:35 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2000-2006 Silicon Graphics, Inc.
|
|
|
|
* All Rights Reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it would be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write the Free Software Foundation,
|
|
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
|
|
|
#include "xfs_fs.h"
|
2013-10-22 23:36:05 +00:00
|
|
|
#include "xfs_shared.h"
|
2013-10-22 23:50:10 +00:00
|
|
|
#include "xfs_format.h"
|
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2013-08-12 10:49:35 +00:00
|
|
|
#include "xfs_mount.h"
|
|
|
|
#include "xfs_inode.h"
|
|
|
|
#include "xfs_error.h"
|
|
|
|
#include "xfs_cksum.h"
|
|
|
|
#include "xfs_icache.h"
|
2013-10-22 23:50:10 +00:00
|
|
|
#include "xfs_trans.h"
|
2013-10-22 23:51:50 +00:00
|
|
|
#include "xfs_ialloc.h"
|
2013-08-12 10:49:35 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check that none of the inode's in the buffer have a next
|
|
|
|
* unlinked field of 0.
|
|
|
|
*/
|
|
|
|
#if defined(DEBUG)
|
|
|
|
void
|
|
|
|
xfs_inobp_check(
|
|
|
|
xfs_mount_t *mp,
|
|
|
|
xfs_buf_t *bp)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int j;
|
|
|
|
xfs_dinode_t *dip;
|
|
|
|
|
|
|
|
j = mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog;
|
|
|
|
|
|
|
|
for (i = 0; i < j; i++) {
|
2015-06-21 23:44:29 +00:00
|
|
|
dip = xfs_buf_offset(bp, i * mp->m_sb.sb_inodesize);
|
2013-08-12 10:49:35 +00:00
|
|
|
if (!dip->di_next_unlinked) {
|
|
|
|
xfs_alert(mp,
|
2013-09-03 11:47:38 +00:00
|
|
|
"Detected bogus zero next_unlinked field in inode %d buffer 0x%llx.",
|
|
|
|
i, (long long)bp->b_bn);
|
2013-08-12 10:49:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-08-27 01:39:37 +00:00
|
|
|
/*
|
|
|
|
* If we are doing readahead on an inode buffer, we might be in log recovery
|
|
|
|
* reading an inode allocation buffer that hasn't yet been replayed, and hence
|
|
|
|
* has not had the inode cores stamped into it. Hence for readahead, the buffer
|
|
|
|
* may be potentially invalid.
|
|
|
|
*
|
2016-01-11 20:03:44 +00:00
|
|
|
* If the readahead buffer is invalid, we need to mark it with an error and
|
|
|
|
* clear the DONE status of the buffer so that a followup read will re-read it
|
|
|
|
* from disk. We don't report the error otherwise to avoid warnings during log
|
|
|
|
* recovery and we don't get unnecssary panics on debug kernels. We use EIO here
|
|
|
|
* because all we want to do is say readahead failed; there is no-one to report
|
|
|
|
* the error to, so this will distinguish it from a non-ra verifier failure.
|
2016-01-11 20:04:01 +00:00
|
|
|
* Changes to this readahead error behavour also need to be reflected in
|
|
|
|
* xfs_dquot_buf_readahead_verify().
|
2013-08-27 01:39:37 +00:00
|
|
|
*/
|
2013-08-12 10:49:35 +00:00
|
|
|
static void
|
|
|
|
xfs_inode_buf_verify(
|
2013-08-27 01:39:37 +00:00
|
|
|
struct xfs_buf *bp,
|
|
|
|
bool readahead)
|
2013-08-12 10:49:35 +00:00
|
|
|
{
|
|
|
|
struct xfs_mount *mp = bp->b_target->bt_mount;
|
|
|
|
int i;
|
|
|
|
int ni;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Validate the magic number and version of every inode in the buffer
|
|
|
|
*/
|
|
|
|
ni = XFS_BB_TO_FSB(mp, bp->b_length) * mp->m_sb.sb_inopblock;
|
|
|
|
for (i = 0; i < ni; i++) {
|
|
|
|
int di_ok;
|
|
|
|
xfs_dinode_t *dip;
|
|
|
|
|
2015-06-21 23:44:29 +00:00
|
|
|
dip = xfs_buf_offset(bp, (i << mp->m_sb.sb_inodelog));
|
2013-08-12 10:49:35 +00:00
|
|
|
di_ok = dip->di_magic == cpu_to_be16(XFS_DINODE_MAGIC) &&
|
|
|
|
XFS_DINODE_GOOD_VERSION(dip->di_version);
|
|
|
|
if (unlikely(XFS_TEST_ERROR(!di_ok, mp,
|
|
|
|
XFS_ERRTAG_ITOBP_INOTOBP,
|
|
|
|
XFS_RANDOM_ITOBP_INOTOBP))) {
|
2013-08-27 01:39:37 +00:00
|
|
|
if (readahead) {
|
|
|
|
bp->b_flags &= ~XBF_DONE;
|
2016-01-11 20:03:44 +00:00
|
|
|
xfs_buf_ioerror(bp, -EIO);
|
2013-08-27 01:39:37 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-06-25 04:58:08 +00:00
|
|
|
xfs_buf_ioerror(bp, -EFSCORRUPTED);
|
2014-02-27 04:23:10 +00:00
|
|
|
xfs_verifier_error(bp);
|
2013-08-12 10:49:35 +00:00
|
|
|
#ifdef DEBUG
|
2013-09-03 11:47:38 +00:00
|
|
|
xfs_alert(mp,
|
2013-08-12 10:49:35 +00:00
|
|
|
"bad inode magic/vsn daddr %lld #%d (magic=%x)",
|
|
|
|
(unsigned long long)bp->b_bn, i,
|
|
|
|
be16_to_cpu(dip->di_magic));
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
xfs_inobp_check(mp, bp);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
xfs_inode_buf_read_verify(
|
|
|
|
struct xfs_buf *bp)
|
|
|
|
{
|
2013-08-27 01:39:37 +00:00
|
|
|
xfs_inode_buf_verify(bp, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xfs_inode_buf_readahead_verify(
|
|
|
|
struct xfs_buf *bp)
|
|
|
|
{
|
|
|
|
xfs_inode_buf_verify(bp, true);
|
2013-08-12 10:49:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xfs_inode_buf_write_verify(
|
|
|
|
struct xfs_buf *bp)
|
|
|
|
{
|
2013-08-27 01:39:37 +00:00
|
|
|
xfs_inode_buf_verify(bp, false);
|
2013-08-12 10:49:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const struct xfs_buf_ops xfs_inode_buf_ops = {
|
2016-01-04 05:10:19 +00:00
|
|
|
.name = "xfs_inode",
|
2013-08-12 10:49:35 +00:00
|
|
|
.verify_read = xfs_inode_buf_read_verify,
|
|
|
|
.verify_write = xfs_inode_buf_write_verify,
|
|
|
|
};
|
|
|
|
|
2013-08-27 01:39:37 +00:00
|
|
|
const struct xfs_buf_ops xfs_inode_buf_ra_ops = {
|
2016-01-04 05:10:19 +00:00
|
|
|
.name = "xxfs_inode_ra",
|
2013-08-27 01:39:37 +00:00
|
|
|
.verify_read = xfs_inode_buf_readahead_verify,
|
|
|
|
.verify_write = xfs_inode_buf_write_verify,
|
|
|
|
};
|
|
|
|
|
2013-08-12 10:49:35 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This routine is called to map an inode to the buffer containing the on-disk
|
|
|
|
* version of the inode. It returns a pointer to the buffer containing the
|
|
|
|
* on-disk inode in the bpp parameter, and in the dipp parameter it returns a
|
|
|
|
* pointer to the on-disk inode within that buffer.
|
|
|
|
*
|
|
|
|
* If a non-zero error is returned, then the contents of bpp and dipp are
|
|
|
|
* undefined.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_imap_to_bp(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
struct xfs_imap *imap,
|
|
|
|
struct xfs_dinode **dipp,
|
|
|
|
struct xfs_buf **bpp,
|
|
|
|
uint buf_flags,
|
|
|
|
uint iget_flags)
|
|
|
|
{
|
|
|
|
struct xfs_buf *bp;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
buf_flags |= XBF_UNMAPPED;
|
|
|
|
error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, imap->im_blkno,
|
|
|
|
(int)imap->im_len, buf_flags, &bp,
|
|
|
|
&xfs_inode_buf_ops);
|
|
|
|
if (error) {
|
2014-06-25 04:58:08 +00:00
|
|
|
if (error == -EAGAIN) {
|
2013-08-12 10:49:35 +00:00
|
|
|
ASSERT(buf_flags & XBF_TRYLOCK);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2014-06-25 04:58:08 +00:00
|
|
|
if (error == -EFSCORRUPTED &&
|
2013-08-12 10:49:35 +00:00
|
|
|
(iget_flags & XFS_IGET_UNTRUSTED))
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EINVAL;
|
2013-08-12 10:49:35 +00:00
|
|
|
|
|
|
|
xfs_warn(mp, "%s: xfs_trans_read_buf() returned error %d.",
|
|
|
|
__func__, error);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
*bpp = bp;
|
2015-06-21 23:44:29 +00:00
|
|
|
*dipp = xfs_buf_offset(bp, imap->im_boffset);
|
2013-08-12 10:49:35 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-30 00:23:45 +00:00
|
|
|
void
|
2013-08-12 10:49:35 +00:00
|
|
|
xfs_dinode_from_disk(
|
|
|
|
xfs_icdinode_t *to,
|
|
|
|
xfs_dinode_t *from)
|
|
|
|
{
|
|
|
|
to->di_magic = be16_to_cpu(from->di_magic);
|
|
|
|
to->di_mode = be16_to_cpu(from->di_mode);
|
|
|
|
to->di_version = from ->di_version;
|
|
|
|
to->di_format = from->di_format;
|
|
|
|
to->di_onlink = be16_to_cpu(from->di_onlink);
|
|
|
|
to->di_uid = be32_to_cpu(from->di_uid);
|
|
|
|
to->di_gid = be32_to_cpu(from->di_gid);
|
|
|
|
to->di_nlink = be32_to_cpu(from->di_nlink);
|
|
|
|
to->di_projid_lo = be16_to_cpu(from->di_projid_lo);
|
|
|
|
to->di_projid_hi = be16_to_cpu(from->di_projid_hi);
|
|
|
|
memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad));
|
|
|
|
to->di_flushiter = be16_to_cpu(from->di_flushiter);
|
|
|
|
to->di_atime.t_sec = be32_to_cpu(from->di_atime.t_sec);
|
|
|
|
to->di_atime.t_nsec = be32_to_cpu(from->di_atime.t_nsec);
|
|
|
|
to->di_mtime.t_sec = be32_to_cpu(from->di_mtime.t_sec);
|
|
|
|
to->di_mtime.t_nsec = be32_to_cpu(from->di_mtime.t_nsec);
|
|
|
|
to->di_ctime.t_sec = be32_to_cpu(from->di_ctime.t_sec);
|
|
|
|
to->di_ctime.t_nsec = be32_to_cpu(from->di_ctime.t_nsec);
|
|
|
|
to->di_size = be64_to_cpu(from->di_size);
|
|
|
|
to->di_nblocks = be64_to_cpu(from->di_nblocks);
|
|
|
|
to->di_extsize = be32_to_cpu(from->di_extsize);
|
|
|
|
to->di_nextents = be32_to_cpu(from->di_nextents);
|
|
|
|
to->di_anextents = be16_to_cpu(from->di_anextents);
|
|
|
|
to->di_forkoff = from->di_forkoff;
|
|
|
|
to->di_aformat = from->di_aformat;
|
|
|
|
to->di_dmevmask = be32_to_cpu(from->di_dmevmask);
|
|
|
|
to->di_dmstate = be16_to_cpu(from->di_dmstate);
|
|
|
|
to->di_flags = be16_to_cpu(from->di_flags);
|
|
|
|
to->di_gen = be32_to_cpu(from->di_gen);
|
|
|
|
|
|
|
|
if (to->di_version == 3) {
|
|
|
|
to->di_changecount = be64_to_cpu(from->di_changecount);
|
|
|
|
to->di_crtime.t_sec = be32_to_cpu(from->di_crtime.t_sec);
|
|
|
|
to->di_crtime.t_nsec = be32_to_cpu(from->di_crtime.t_nsec);
|
|
|
|
to->di_flags2 = be64_to_cpu(from->di_flags2);
|
|
|
|
to->di_ino = be64_to_cpu(from->di_ino);
|
|
|
|
to->di_lsn = be64_to_cpu(from->di_lsn);
|
|
|
|
memcpy(to->di_pad2, from->di_pad2, sizeof(to->di_pad2));
|
|
|
|
uuid_copy(&to->di_uuid, &from->di_uuid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_dinode_to_disk(
|
|
|
|
xfs_dinode_t *to,
|
|
|
|
xfs_icdinode_t *from)
|
|
|
|
{
|
|
|
|
to->di_magic = cpu_to_be16(from->di_magic);
|
|
|
|
to->di_mode = cpu_to_be16(from->di_mode);
|
|
|
|
to->di_version = from ->di_version;
|
|
|
|
to->di_format = from->di_format;
|
|
|
|
to->di_onlink = cpu_to_be16(from->di_onlink);
|
|
|
|
to->di_uid = cpu_to_be32(from->di_uid);
|
|
|
|
to->di_gid = cpu_to_be32(from->di_gid);
|
|
|
|
to->di_nlink = cpu_to_be32(from->di_nlink);
|
|
|
|
to->di_projid_lo = cpu_to_be16(from->di_projid_lo);
|
|
|
|
to->di_projid_hi = cpu_to_be16(from->di_projid_hi);
|
|
|
|
memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad));
|
|
|
|
to->di_atime.t_sec = cpu_to_be32(from->di_atime.t_sec);
|
|
|
|
to->di_atime.t_nsec = cpu_to_be32(from->di_atime.t_nsec);
|
|
|
|
to->di_mtime.t_sec = cpu_to_be32(from->di_mtime.t_sec);
|
|
|
|
to->di_mtime.t_nsec = cpu_to_be32(from->di_mtime.t_nsec);
|
|
|
|
to->di_ctime.t_sec = cpu_to_be32(from->di_ctime.t_sec);
|
|
|
|
to->di_ctime.t_nsec = cpu_to_be32(from->di_ctime.t_nsec);
|
|
|
|
to->di_size = cpu_to_be64(from->di_size);
|
|
|
|
to->di_nblocks = cpu_to_be64(from->di_nblocks);
|
|
|
|
to->di_extsize = cpu_to_be32(from->di_extsize);
|
|
|
|
to->di_nextents = cpu_to_be32(from->di_nextents);
|
|
|
|
to->di_anextents = cpu_to_be16(from->di_anextents);
|
|
|
|
to->di_forkoff = from->di_forkoff;
|
|
|
|
to->di_aformat = from->di_aformat;
|
|
|
|
to->di_dmevmask = cpu_to_be32(from->di_dmevmask);
|
|
|
|
to->di_dmstate = cpu_to_be16(from->di_dmstate);
|
|
|
|
to->di_flags = cpu_to_be16(from->di_flags);
|
|
|
|
to->di_gen = cpu_to_be32(from->di_gen);
|
|
|
|
|
|
|
|
if (from->di_version == 3) {
|
|
|
|
to->di_changecount = cpu_to_be64(from->di_changecount);
|
|
|
|
to->di_crtime.t_sec = cpu_to_be32(from->di_crtime.t_sec);
|
|
|
|
to->di_crtime.t_nsec = cpu_to_be32(from->di_crtime.t_nsec);
|
|
|
|
to->di_flags2 = cpu_to_be64(from->di_flags2);
|
|
|
|
to->di_ino = cpu_to_be64(from->di_ino);
|
|
|
|
to->di_lsn = cpu_to_be64(from->di_lsn);
|
|
|
|
memcpy(to->di_pad2, from->di_pad2, sizeof(to->di_pad2));
|
|
|
|
uuid_copy(&to->di_uuid, &from->di_uuid);
|
|
|
|
to->di_flushiter = 0;
|
|
|
|
} else {
|
|
|
|
to->di_flushiter = cpu_to_be16(from->di_flushiter);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
xfs_dinode_verify(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
struct xfs_dinode *dip)
|
|
|
|
{
|
|
|
|
if (dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* only version 3 or greater inodes are extensively verified here */
|
|
|
|
if (dip->di_version < 3)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (!xfs_sb_version_hascrc(&mp->m_sb))
|
|
|
|
return false;
|
|
|
|
if (!xfs_verify_cksum((char *)dip, mp->m_sb.sb_inodesize,
|
2014-02-27 04:15:27 +00:00
|
|
|
XFS_DINODE_CRC_OFF))
|
2013-08-12 10:49:35 +00:00
|
|
|
return false;
|
|
|
|
if (be64_to_cpu(dip->di_ino) != ip->i_ino)
|
|
|
|
return false;
|
2015-07-29 01:53:31 +00:00
|
|
|
if (!uuid_equal(&dip->di_uuid, &mp->m_sb.sb_meta_uuid))
|
2013-08-12 10:49:35 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_dinode_calc_crc(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_dinode *dip)
|
|
|
|
{
|
|
|
|
__uint32_t crc;
|
|
|
|
|
|
|
|
if (dip->di_version < 3)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ASSERT(xfs_sb_version_hascrc(&mp->m_sb));
|
|
|
|
crc = xfs_start_cksum((char *)dip, mp->m_sb.sb_inodesize,
|
2014-02-27 04:15:27 +00:00
|
|
|
XFS_DINODE_CRC_OFF);
|
2013-08-12 10:49:35 +00:00
|
|
|
dip->di_crc = xfs_end_cksum(crc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read the disk inode attributes into the in-core inode structure.
|
|
|
|
*
|
|
|
|
* For version 5 superblocks, if we are initialising a new inode and we are not
|
|
|
|
* utilising the XFS_MOUNT_IKEEP inode cluster mode, we can simple build the new
|
|
|
|
* inode core with a random generation number. If we are keeping inodes around,
|
|
|
|
* we need to read the inode cluster to get the existing generation number off
|
|
|
|
* disk. Further, if we are using version 4 superblocks (i.e. v1/v2 inode
|
|
|
|
* format) then log recovery is dependent on the di_flushiter field being
|
|
|
|
* initialised from the current on-disk value and hence we must also read the
|
|
|
|
* inode off disk.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_iread(
|
|
|
|
xfs_mount_t *mp,
|
|
|
|
xfs_trans_t *tp,
|
|
|
|
xfs_inode_t *ip,
|
|
|
|
uint iget_flags)
|
|
|
|
{
|
|
|
|
xfs_buf_t *bp;
|
|
|
|
xfs_dinode_t *dip;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fill in the location information in the in-core inode.
|
|
|
|
*/
|
|
|
|
error = xfs_imap(mp, tp, ip->i_ino, &ip->i_imap, iget_flags);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
/* shortcut IO on inode allocation if possible */
|
|
|
|
if ((iget_flags & XFS_IGET_CREATE) &&
|
|
|
|
xfs_sb_version_hascrc(&mp->m_sb) &&
|
|
|
|
!(mp->m_flags & XFS_MOUNT_IKEEP)) {
|
|
|
|
/* initialise the on-disk inode core */
|
|
|
|
memset(&ip->i_d, 0, sizeof(ip->i_d));
|
|
|
|
ip->i_d.di_magic = XFS_DINODE_MAGIC;
|
|
|
|
ip->i_d.di_gen = prandom_u32();
|
|
|
|
if (xfs_sb_version_hascrc(&mp->m_sb)) {
|
|
|
|
ip->i_d.di_version = 3;
|
|
|
|
ip->i_d.di_ino = ip->i_ino;
|
2015-07-29 01:53:31 +00:00
|
|
|
uuid_copy(&ip->i_d.di_uuid, &mp->m_sb.sb_meta_uuid);
|
2013-08-12 10:49:35 +00:00
|
|
|
} else
|
|
|
|
ip->i_d.di_version = 2;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get pointers to the on-disk inode and the buffer containing it.
|
|
|
|
*/
|
|
|
|
error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &dip, &bp, 0, iget_flags);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
/* even unallocated inodes are verified */
|
|
|
|
if (!xfs_dinode_verify(mp, ip, dip)) {
|
|
|
|
xfs_alert(mp, "%s: validation failed for inode %lld failed",
|
|
|
|
__func__, ip->i_ino);
|
|
|
|
|
|
|
|
XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, dip);
|
2014-06-25 04:58:08 +00:00
|
|
|
error = -EFSCORRUPTED;
|
2013-08-12 10:49:35 +00:00
|
|
|
goto out_brelse;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the on-disk inode is already linked to a directory
|
|
|
|
* entry, copy all of the inode into the in-core inode.
|
|
|
|
* xfs_iformat_fork() handles copying in the inode format
|
|
|
|
* specific information.
|
|
|
|
* Otherwise, just get the truly permanent information.
|
|
|
|
*/
|
|
|
|
if (dip->di_mode) {
|
|
|
|
xfs_dinode_from_disk(&ip->i_d, dip);
|
|
|
|
error = xfs_iformat_fork(ip, dip);
|
|
|
|
if (error) {
|
|
|
|
#ifdef DEBUG
|
|
|
|
xfs_alert(mp, "%s: xfs_iformat() returned error %d",
|
|
|
|
__func__, error);
|
|
|
|
#endif /* DEBUG */
|
|
|
|
goto out_brelse;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Partial initialisation of the in-core inode. Just the bits
|
|
|
|
* that xfs_ialloc won't overwrite or relies on being correct.
|
|
|
|
*/
|
|
|
|
ip->i_d.di_magic = be16_to_cpu(dip->di_magic);
|
|
|
|
ip->i_d.di_version = dip->di_version;
|
|
|
|
ip->i_d.di_gen = be32_to_cpu(dip->di_gen);
|
|
|
|
ip->i_d.di_flushiter = be16_to_cpu(dip->di_flushiter);
|
|
|
|
|
|
|
|
if (dip->di_version == 3) {
|
|
|
|
ip->i_d.di_ino = be64_to_cpu(dip->di_ino);
|
|
|
|
uuid_copy(&ip->i_d.di_uuid, &dip->di_uuid);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure to pull in the mode here as well in
|
|
|
|
* case the inode is released without being used.
|
|
|
|
* This ensures that xfs_inactive() will see that
|
|
|
|
* the inode is already free and not try to mess
|
|
|
|
* with the uninitialized part of it.
|
|
|
|
*/
|
|
|
|
ip->i_d.di_mode = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2014-05-19 21:46:40 +00:00
|
|
|
* Automatically convert version 1 inode formats in memory to version 2
|
|
|
|
* inode format. If the inode is modified, it will get logged and
|
|
|
|
* rewritten as a version 2 inode. We can do this because we set the
|
|
|
|
* superblock feature bit for v2 inodes unconditionally during mount
|
|
|
|
* and it means the reast of the code can assume the inode version is 2
|
|
|
|
* or higher.
|
2013-08-12 10:49:35 +00:00
|
|
|
*/
|
|
|
|
if (ip->i_d.di_version == 1) {
|
2014-05-19 21:46:40 +00:00
|
|
|
ip->i_d.di_version = 2;
|
|
|
|
memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
|
2013-08-12 10:49:35 +00:00
|
|
|
ip->i_d.di_nlink = ip->i_d.di_onlink;
|
|
|
|
ip->i_d.di_onlink = 0;
|
|
|
|
xfs_set_projid(ip, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
ip->i_delayed_blks = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mark the buffer containing the inode as something to keep
|
|
|
|
* around for a while. This helps to keep recently accessed
|
|
|
|
* meta-data in-core longer.
|
|
|
|
*/
|
|
|
|
xfs_buf_set_ref(bp, XFS_INO_REF);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Use xfs_trans_brelse() to release the buffer containing the on-disk
|
|
|
|
* inode, because it was acquired with xfs_trans_read_buf() in
|
|
|
|
* xfs_imap_to_bp() above. If tp is NULL, this is just a normal
|
|
|
|
* brelse(). If we're within a transaction, then xfs_trans_brelse()
|
|
|
|
* will only release the buffer if it is not dirty within the
|
|
|
|
* transaction. It will be OK to release the buffer in this case,
|
|
|
|
* because inodes on disk are never destroyed and we will be locking the
|
|
|
|
* new in-core inode before putting it in the cache where other
|
|
|
|
* processes can find it. Thus we don't have to worry about the inode
|
|
|
|
* being changed just because we released the buffer.
|
|
|
|
*/
|
|
|
|
out_brelse:
|
|
|
|
xfs_trans_brelse(tp, bp);
|
|
|
|
return error;
|
|
|
|
}
|