Skip to content

Commit

Permalink
xfs: add CRC checks to block format directory blocks
Browse files Browse the repository at this point in the history 
Now that directory buffers are made from a single struct xfs_buf, we
can add CRC calculation and checking callbacks. While there, add all
the fields to the on disk structures for future functionality such
as d_type support, uuids, block numbers, owner inode, etc.

To distinguish between the different on disk formats, change the
magic numbers for the new format directory blocks.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
  • Loading branch information
Dave Chinner authored and Ben Myers committed Apr 27, 2013
1 parent f948dd7 commit f5f3d9b
Show file tree
Hide file tree
Showing 7 changed files with 344 additions and 105 deletions.
132 changes: 94 additions & 38 deletions fs/xfs/xfs_dir2_block.c
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,6 @@
/*
* Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
* Copyright (c) 2013 Red Hat, Inc.
* All Rights Reserved.
*
* This program is free software; you can redistribute it and/or
Expand Down Expand Up @@ -28,11 +29,13 @@
#include "xfs_dinode.h"
#include "xfs_inode.h"
#include "xfs_inode_item.h"
#include "xfs_buf_item.h"
#include "xfs_dir2.h"
#include "xfs_dir2_format.h"
#include "xfs_dir2_priv.h"
#include "xfs_error.h"
#include "xfs_trace.h"
#include "xfs_cksum.h"

/*
* Local function prototypes.
Expand All @@ -56,52 +59,104 @@ xfs_dir_startup(void)
xfs_dir_hash_dotdot = xfs_da_hashname((unsigned char *)"..", 2);
}

static void
xfs_dir2_block_verify(
static bool
xfs_dir3_block_verify(
struct xfs_buf *bp)
{
struct xfs_mount *mp = bp->b_target->bt_mount;
struct xfs_dir2_data_hdr *hdr = bp->b_addr;
int block_ok = 0;

block_ok = hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC);
block_ok = block_ok && __xfs_dir2_data_check(NULL, bp) == 0;

if (!block_ok) {
XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, hdr);
xfs_buf_ioerror(bp, EFSCORRUPTED);
struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;

if (xfs_sb_version_hascrc(&mp->m_sb)) {
if (hdr3->magic != cpu_to_be32(XFS_DIR3_BLOCK_MAGIC))
return false;
if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_uuid))
return false;
if (be64_to_cpu(hdr3->blkno) != bp->b_bn)
return false;
} else {
if (hdr3->magic != cpu_to_be32(XFS_DIR2_BLOCK_MAGIC))
return false;
}
if (__xfs_dir2_data_check(NULL, bp))
return false;
return true;
}

static void
xfs_dir2_block_read_verify(
xfs_dir3_block_read_verify(
struct xfs_buf *bp)
{
xfs_dir2_block_verify(bp);
struct xfs_mount *mp = bp->b_target->bt_mount;

if ((xfs_sb_version_hascrc(&mp->m_sb) &&
!xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length),
XFS_DIR3_DATA_CRC_OFF)) ||
!xfs_dir3_block_verify(bp)) {
XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
xfs_buf_ioerror(bp, EFSCORRUPTED);
}
}

static void
xfs_dir2_block_write_verify(
xfs_dir3_block_write_verify(
struct xfs_buf *bp)
{
xfs_dir2_block_verify(bp);
struct xfs_mount *mp = bp->b_target->bt_mount;
struct xfs_buf_log_item *bip = bp->b_fspriv;
struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;

if (!xfs_dir3_block_verify(bp)) {
XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
xfs_buf_ioerror(bp, EFSCORRUPTED);
return;
}

if (!xfs_sb_version_hascrc(&mp->m_sb))
return;

if (bip)
hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn);

xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), XFS_DIR3_DATA_CRC_OFF);
}

const struct xfs_buf_ops xfs_dir2_block_buf_ops = {
.verify_read = xfs_dir2_block_read_verify,
.verify_write = xfs_dir2_block_write_verify,
const struct xfs_buf_ops xfs_dir3_block_buf_ops = {
.verify_read = xfs_dir3_block_read_verify,
.verify_write = xfs_dir3_block_write_verify,
};

static int
xfs_dir2_block_read(
xfs_dir3_block_read(
struct xfs_trans *tp,
struct xfs_inode *dp,
struct xfs_buf **bpp)
{
struct xfs_mount *mp = dp->i_mount;

return xfs_da_read_buf(tp, dp, mp->m_dirdatablk, -1, bpp,
XFS_DATA_FORK, &xfs_dir2_block_buf_ops);
XFS_DATA_FORK, &xfs_dir3_block_buf_ops);
}

static void
xfs_dir3_block_init(
struct xfs_mount *mp,
struct xfs_buf *bp,
struct xfs_inode *dp)
{
struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;

bp->b_ops = &xfs_dir3_block_buf_ops;

if (xfs_sb_version_hascrc(&mp->m_sb)) {
memset(hdr3, 0, sizeof(*hdr3));
hdr3->magic = cpu_to_be32(XFS_DIR3_BLOCK_MAGIC);
hdr3->blkno = cpu_to_be64(bp->b_bn);
hdr3->owner = cpu_to_be64(dp->i_ino);
uuid_copy(&hdr3->uuid, &mp->m_sb.sb_uuid);
return;

}
hdr3->magic = cpu_to_be32(XFS_DIR2_BLOCK_MAGIC);
}

static void
Expand All @@ -121,7 +176,7 @@ xfs_dir2_block_need_space(
struct xfs_dir2_data_unused *enddup = NULL;

*compact = 0;
bf = hdr->bestfree;
bf = xfs_dir3_data_bestfree_p(hdr);

/*
* If there are stale entries we'll use one for the leaf.
Expand Down Expand Up @@ -303,7 +358,7 @@ xfs_dir2_block_addname(
mp = dp->i_mount;

/* Read the (one and only) directory block into bp. */
error = xfs_dir2_block_read(tp, dp, &bp);
error = xfs_dir3_block_read(tp, dp, &bp);
if (error)
return error;

Expand Down Expand Up @@ -531,7 +586,7 @@ xfs_dir2_block_getdents(
if (xfs_dir2_dataptr_to_db(mp, *offset) > mp->m_dirdatablk)
return 0;

error = xfs_dir2_block_read(NULL, dp, &bp);
error = xfs_dir3_block_read(NULL, dp, &bp);
if (error)
return error;

Expand All @@ -546,7 +601,7 @@ xfs_dir2_block_getdents(
* Set up values for the loop.
*/
btp = xfs_dir2_block_tail_p(mp, hdr);
ptr = (char *)(hdr + 1);
ptr = (char *)xfs_dir3_data_entry_p(hdr);
endptr = (char *)xfs_dir2_block_leaf_p(btp);

/*
Expand Down Expand Up @@ -711,7 +766,7 @@ xfs_dir2_block_lookup_int(
tp = args->trans;
mp = dp->i_mount;

error = xfs_dir2_block_read(tp, dp, &bp);
error = xfs_dir3_block_read(tp, dp, &bp);
if (error)
return error;

Expand Down Expand Up @@ -974,9 +1029,12 @@ xfs_dir2_leaf_to_block(
* These will show up in the leaf bests table.
*/
while (dp->i_d.di_size > mp->m_dirblksize) {
int hdrsz;

hdrsz = xfs_dir3_data_hdr_size(xfs_sb_version_hascrc(&mp->m_sb));
bestsp = xfs_dir2_leaf_bests_p(ltp);
if (be16_to_cpu(bestsp[be32_to_cpu(ltp->bestcount) - 1]) ==
mp->m_dirblksize - (uint)sizeof(*hdr)) {
mp->m_dirblksize - hdrsz) {
if ((error =
xfs_dir2_leaf_trim_data(args, lbp,
(xfs_dir2_db_t)(be32_to_cpu(ltp->bestcount) - 1))))
Expand Down Expand Up @@ -1014,8 +1072,8 @@ xfs_dir2_leaf_to_block(
/*
* Start converting it to block form.
*/
dbp->b_ops = &xfs_dir2_block_buf_ops;
hdr->magic = cpu_to_be32(XFS_DIR2_BLOCK_MAGIC);
xfs_dir3_block_init(mp, dbp, dp);

needlog = 1;
needscan = 0;
/*
Expand Down Expand Up @@ -1137,16 +1195,16 @@ xfs_dir2_sf_to_block(
return error;
}
/*
* Initialize the data block.
* Initialize the data block, then convert it to block format.
*/
error = xfs_dir2_data_init(args, blkno, &bp);
error = xfs_dir3_data_init(args, blkno, &bp);
if (error) {
kmem_free(sfp);
return error;
}
bp->b_ops = &xfs_dir2_block_buf_ops;
xfs_dir3_block_init(mp, bp, dp);
hdr = bp->b_addr;
hdr->magic = cpu_to_be32(XFS_DIR2_BLOCK_MAGIC);

/*
* Compute size of block "tail" area.
*/
Expand All @@ -1156,7 +1214,7 @@ xfs_dir2_sf_to_block(
* The whole thing is initialized to free by the init routine.
* Say we're using the leaf and tail area.
*/
dup = (xfs_dir2_data_unused_t *)(hdr + 1);
dup = xfs_dir3_data_unused_p(hdr);
needlog = needscan = 0;
xfs_dir2_data_use_free(tp, bp, dup, mp->m_dirblksize - i, i, &needlog,
&needscan);
Expand All @@ -1178,8 +1236,7 @@ xfs_dir2_sf_to_block(
/*
* Create entry for .
*/
dep = (xfs_dir2_data_entry_t *)
((char *)hdr + XFS_DIR2_DATA_DOT_OFFSET);
dep = xfs_dir3_data_dot_entry_p(hdr);
dep->inumber = cpu_to_be64(dp->i_ino);
dep->namelen = 1;
dep->name[0] = '.';
Expand All @@ -1192,8 +1249,7 @@ xfs_dir2_sf_to_block(
/*
* Create entry for ..
*/
dep = (xfs_dir2_data_entry_t *)
((char *)hdr + XFS_DIR2_DATA_DOTDOT_OFFSET);
dep = xfs_dir3_data_dotdot_entry_p(hdr);
dep->inumber = cpu_to_be64(xfs_dir2_sf_get_parent_ino(sfp));
dep->namelen = 2;
dep->name[0] = dep->name[1] = '.';
Expand All @@ -1203,7 +1259,7 @@ xfs_dir2_sf_to_block(
blp[1].hashval = cpu_to_be32(xfs_dir_hash_dotdot);
blp[1].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(mp,
(char *)dep - (char *)hdr));
offset = XFS_DIR2_DATA_FIRST_OFFSET;
offset = xfs_dir3_data_first_offset(hdr);
/*
* Loop over existing entries, stuff them in.
*/
Expand Down
Loading

0 comments on commit f5f3d9b

Please sign in to comment.